@atcute/lex-cli 2.4.0 → 2.5.1

package/src/commands/export.ts

@@ -0,0 +1,106 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+
+import type { LexiconDoc } from '@atcute/lexicon-doc';
+import { merge, object } from '@optique/core/constructs';
+import { message } from '@optique/core/message';
+import { type InferValue } from '@optique/core/parser';
+import { command, constant } from '@optique/core/primitives';
+import pc from 'picocolors';
+import prettier from 'prettier';
+
+import { loadConfig, type ExportConfig, type NormalizedConfig } from '../config.js';
+import { loadLexicons } from '../lexicon-loader.js';
+import { sharedOptions } from '../shared-options.js';
+
+export const exportCommandSchema = command(
+	'export',
+	merge(
+		object({
+			type: constant('export'),
+		}),
+		sharedOptions,
+	),
+	{
+		brief: message`export lexicon documents as JSON files`,
+		description: message`exports lexicon documents (from JSON or builder files) to JSON format for publishing or distribution.`,
+	},
+);
+
+export type ExportCommand = InferValue<typeof exportCommandSchema>;
+
+/**
+ * ensures export configuration is present
+ * @param config the normalized config
+ * @returns the export config
+ */
+const ensureExportConfig = (config: NormalizedConfig): ExportConfig => {
+	if (!config.export) {
+		console.error(pc.bold(pc.red(`export configuration missing`)));
+		process.exit(1);
+	}
+
+	return config.export;
+};
+
+/**
+ * writes a lexicon document to disk as formatted JSON
+ * @param outdir output directory
+ * @param nsid the NSID of the lexicon
+ * @param doc the lexicon document
+ * @param prettierConfig prettier configuration
+ */
+const writeLexicon = async (
+	outdir: string,
+	nsid: string,
+	doc: LexiconDoc,
+	prettierConfig: prettier.Options | null,
+): Promise<void> => {
+	const nsidPath = nsid.replaceAll('.', '/');
+	const target = path.join(outdir, `${nsidPath}.json`);
+	const dirname = path.dirname(target);
+
+	const code = await prettier.format(JSON.stringify(doc, null, 2), {
+		...(prettierConfig ?? {}),
+		parser: 'json',
+	});
+
+	await fs.mkdir(dirname, { recursive: true });
+	await fs.writeFile(target, code);
+};
+
+/**
+ * runs the export command to write lexicon documents as JSON files
+ * @param args parsed command arguments
+ */
+export const runExport = async (args: ExportCommand): Promise<void> => {
+	const config = await loadConfig(args.config);
+	const exportConfig = ensureExportConfig(config);
+
+	// use export.files if specified, otherwise fall back to root files config
+	const files = exportConfig.files ?? config.files;
+	const outdir = path.resolve(config.root, exportConfig.outdir);
+	const prettierConfig = await prettier.resolveConfig(config.root, { editorconfig: true });
+
+	// load lexicons from files
+	const loaded = await loadLexicons(files, config.root);
+
+	if (loaded.length === 0) {
+		console.warn(pc.yellow(`warning: no lexicons found to export`));
+		return;
+	}
+
+	// clean output directory if requested
+	if (exportConfig.clean) {
+		await fs.rm(outdir, { recursive: true, force: true });
+	}
+
+	await fs.mkdir(outdir, { recursive: true });
+
+	// write each lexicon as JSON
+	for (const { nsid, doc } of loaded) {
+		await writeLexicon(outdir, nsid, doc, prettierConfig);
+	}
+
+	console.log(pc.green(`exported ${loaded.length} lexicon(s) to ${outdir}`));
+};

package/src/commands/generate.ts

@@ -0,0 +1,170 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+
+import { merge, object } from '@optique/core/constructs';
+import { message } from '@optique/core/message';
+import { type InferValue } from '@optique/core/parser';
+import { command, constant } from '@optique/core/primitives';
+import pc from 'picocolors';
+
+import { generateLexiconApi, type ImportMapping } from '../codegen.js';
+import { loadConfig } from '../config.js';
+import { loadLexicons } from '../lexicon-loader.js';
+import { packageJsonSchema } from '../lexicon-metadata.js';
+import { sharedOptions } from '../shared-options.js';
+
+/**
+ * resolves package imports to ImportMapping[]
+ */
+const resolveImportsToMappings = async (
+	imports: string[],
+	configDirname: string,
+): Promise<ImportMapping[]> => {
+	const mappings: ImportMapping[] = [];
+
+	for (const packageName of imports) {
+		// walk up from config directory to find package in node_modules
+		let packageJson: unknown;
+		let currentDir = configDirname;
+		let found = false;
+
+		while (currentDir !== path.dirname(currentDir)) {
+			const candidatePath = path.join(currentDir, 'node_modules', packageName, 'package.json');
+			try {
+				const content = await fs.readFile(candidatePath, 'utf8');
+				packageJson = JSON.parse(content);
+				found = true;
+				break;
+			} catch (err: any) {
+				// only continue to parent if file not found
+				if (err.code !== 'ENOENT') {
+					console.error(pc.bold(pc.red(`failed to read package.json for "${packageName}":`)));
+					console.error(err);
+					process.exit(1);
+				}
+
+				// not found, try parent directory
+				currentDir = path.dirname(currentDir);
+			}
+		}
+
+		if (!found) {
+			console.error(pc.bold(pc.red(`failed to resolve package "${packageName}"`)));
+			console.error(`Could not find package in node_modules starting from ${configDirname}`);
+			process.exit(1);
+		}
+
+		// validate package.json
+		const result = packageJsonSchema.try(packageJson, { mode: 'passthrough' });
+		if (!result.ok) {
+			console.error(pc.bold(pc.red(`invalid atcute:lexicons in "${packageName}":`)));
+			console.error(result.message);
+
+			for (const issue of result.issues) {
+				console.log(`- ${issue.code} at .${issue.path.join('.')}`);
+			}
+
+			process.exit(1);
+		}
+
+		const lexicons = result.value['atcute:lexicons'];
+		if (!lexicons?.mappings) {
+			continue;
+		}
+
+		// convert mapping to ImportMapping[]
+		for (const [pattern, entry] of Object.entries(lexicons.mappings)) {
+			const isWildcard = pattern.endsWith('.*');
+
+			mappings.push({
+				nsid: [pattern],
+				imports: (nsid: string) => {
+					// check if pattern matches
+					if (isWildcard) {
+						if (!nsid.startsWith(pattern.slice(0, -1))) {
+							throw new Error(`NSID ${nsid} does not match pattern ${pattern}`);
+						}
+					} else {
+						if (nsid !== pattern) {
+							throw new Error(`NSID ${nsid} does not match pattern ${pattern}`);
+						}
+					}
+
+					const nsidPrefix = isWildcard ? pattern.slice(0, -2) : pattern;
+					const nsidRemainder = isWildcard ? nsid.slice(nsidPrefix.length + 1) : '';
+
+					let expandedPath = entry.path
+						.replaceAll('{{nsid}}', nsid.replaceAll('.', '/'))
+						.replaceAll('{{nsid_remainder}}', nsidRemainder.replaceAll('.', '/'))
+						.replaceAll('{{nsid_prefix}}', nsidPrefix.replaceAll('.', '/'));
+
+					if (expandedPath === '.') {
+						expandedPath = packageName;
+					} else if (expandedPath.startsWith('./')) {
+						expandedPath = `${packageName}/${expandedPath.slice(2)}`;
+					}
+
+					return {
+						type: entry.type,
+						from: expandedPath,
+					};
+				},
+			});
+		}
+	}
+
+	return mappings;
+};
+
+export const generateCommandSchema = command(
+	'generate',
+	merge(
+		object({
+			type: constant('generate'),
+		}),
+		sharedOptions,
+	),
+	{
+		brief: message`generate type definitions from lexicon documents`,
+		description: message`reads lexicon documents from the configured files and generates TypeScript type definitions and runtime validators.`,
+	},
+);
+
+export type GenerateCommand = InferValue<typeof generateCommandSchema>;
+
+/**
+ * runs the generate command to create type definitions from lexicon documents
+ * @param args parsed command arguments
+ */
+export const runGenerate = async (args: GenerateCommand): Promise<void> => {
+	const config = await loadConfig(args.config);
+
+	// resolve imports to mappings
+	const importMappings = config.imports ? await resolveImportsToMappings(config.imports, config.root) : [];
+	const allMappings = [...importMappings, ...(config.mappings ?? [])];
+
+	// load lexicons from files
+	const loaded = await loadLexicons(config.files, config.root);
+	const documents = loaded.map((l) => l.doc);
+
+	const generationResult = await generateLexiconApi({
+		documents: documents,
+		mappings: allMappings,
+		modules: {
+			importSuffix: config.modules?.importSuffix ?? '.js',
+		},
+		prettier: {
+			cwd: process.cwd(),
+		},
+	});
+
+	const outdir = path.join(config.root, config.outdir);
+
+	for (const file of generationResult.files) {
+		const filename = path.join(outdir, file.filename);
+		const dirname = path.dirname(filename);
+
+		await fs.mkdir(dirname, { recursive: true });
+		await fs.writeFile(filename, file.code);
+	}
+};

package/src/{pull.ts → commands/pull.ts}

@@ -1,34 +1,39 @@
 import * as fs from 'node:fs/promises';
-import * as os from 'node:os';
 import * as path from 'node:path';
 
 import { lexiconDoc, refineLexiconDoc, type LexiconDoc } from '@atcute/lexicon-doc';
-import prettier from 'prettier';
+import { merge, object } from '@optique/core/constructs';
+import { message } from '@optique/core/message';
+import { type InferValue } from '@optique/core/parser';
+import { command, constant } from '@optique/core/primitives';
 import pc from 'picocolors';
+import prettier from 'prettier';
 
-import { runGit, GitError } from './git.js';
-import type { NormalizedConfig, PullConfig, SourceConfig } from './config.js';
+import { loadConfig, type NormalizedConfig, type PullConfig, type SourceConfig } from '../config.js';
+import { pullAtprotoSource } from '../pull-sources/atproto.js';
+import { pullGitSource } from '../pull-sources/git.js';
+import type { PullResult, PulledLexicon, SourceLocation } from '../pull-sources/types.js';
+import { sharedOptions } from '../shared-options.js';
+
+export const pullCommandSchema = command(
+	'pull',
+	merge(
+		object({
+			type: constant('pull'),
+		}),
+		sharedOptions,
+	),
+	{
+		brief: message`pull lexicon documents from configured sources`,
+		description: message`fetches lexicon documents from configured git repositories and writes them to the output directory.`,
+	},
+);
+
+export type PullCommand = InferValue<typeof pullCommandSchema>;
 
 interface SourceRevision {
 	source: SourceConfig;
-	rev: string;
-}
-
-interface SourceLocation {
-	absolutePath: string;
-	relativePath: string;
-	sourceDescription: string;
-}
-
-interface PulledLexicon {
-	nsid: string;
-	doc: LexiconDoc;
-	location: SourceLocation;
-}
-
-interface PullResult {
-	pulled: Map<string, PulledLexicon>;
-	rev: string;
+	rev?: string;
 }
 
 const ensurePullConfig = (config: NormalizedConfig): PullConfig => {
@@ -119,99 +124,13 @@ const writeLexicon = async (
 	await fs.writeFile(target, code);
 };
 
-/**
- * pulls lexicon documents from a git repository source
- * @param source git source configuration
- * @returns pulled lexicons and commit hash
- */
-const pullGitSource = async (source: SourceConfig & { type: 'git' }): Promise<PullResult> => {
-	const tempParent = await fs.mkdtemp(path.join(os.tmpdir(), 'lex-cli-pull-'));
-
-	const cloneDir = path.join(tempParent, 'repo');
-
-	try {
-		await runGit(
-			[
-				'clone',
-				'--filter=blob:none',
-				'--depth',
-				'1',
-				'--sparse',
-				...(source.ref ? ['--branch', source.ref, '--single-branch'] : []),
-				source.remote,
-				cloneDir,
-			],
-			{ timeoutMs: 60_000 },
-		);
-	} catch (err) {
-		if (err instanceof GitError) {
-			console.error(pc.bold(pc.red(`git clone failed for ${source.remote}:`)));
-			console.error(err.stderr || err.message);
-			process.exit(1);
-		}
-
-		throw err;
-	}
-
-	try {
-		await runGit(['-C', cloneDir, 'sparse-checkout', 'set', '--no-cone', ...source.pattern], {
-			timeoutMs: 30_000,
-		});
-	} catch (err) {
-		if (err instanceof GitError) {
-			console.error(pc.bold(pc.red(`git sparse-checkout failed for ${source.remote}:`)));
-			console.error(err.stderr || err.message);
-			process.exit(1);
-		}
-
-		throw err;
-	}
-
-	const pulled = new Map<string, PulledLexicon>();
-
-	for await (const filename of fs.glob(source.pattern, { cwd: cloneDir })) {
-		const absolute = path.join(cloneDir, filename);
-		const stat = await fs.stat(absolute);
-
-		if (!stat.isFile()) {
-			continue;
-		}
-
-		const location: SourceLocation = {
-			absolutePath: absolute,
-			relativePath: filename,
-			sourceDescription: source.remote,
-		};
-
-		const doc = await parseLexiconFile(location);
-
-		pulled.set(doc.id, { nsid: doc.id, doc, location });
-	}
-
-	// get the commit hash
-	let rev: string;
-	try {
-		const result = await runGit(['-C', cloneDir, 'rev-parse', 'HEAD'], { timeoutMs: 10_000 });
-		rev = result.stdout.trim();
-	} catch (err) {
-		if (err instanceof GitError) {
-			console.error(pc.bold(pc.red(`git rev-parse failed for ${source.remote}:`)));
-			console.error(err.stderr || err.message);
-			process.exit(1);
-		}
-
-		throw err;
-	}
-
-	await fs.rm(tempParent, { recursive: true, force: true });
-
-	return { pulled, rev };
-};
-
 const pullSource = async (source: SourceConfig): Promise<PullResult> => {
 	switch (source.type) {
 		case 'git': {
-			return pullGitSource(source);
+			return pullGitSource(source, parseLexiconFile);
+		}
+		case 'atproto': {
+			return pullAtprotoSource(source);
 		}
 	}
 };
@@ -232,7 +151,19 @@ const writeSourceReadme = async (
 		switch (source.type) {
 			case 'git': {
 				lines.push(`- ${source.remote}${source.ref ? ` (ref: ${source.ref})` : ``}`);
-				lines.push(`  - commit: ${rev}`);
+				if (rev) {
+					lines.push(`  - commit: ${rev}`);
+				}
+				break;
+			}
+			case 'atproto': {
+				if (source.mode === 'nsids') {
+					lines.push(`- atproto (nsids: ${source.nsids.join(', ')})`);
+				} else {
+					lines.push(
+						`- atproto (authority: ${source.authority}${source.pattern ? `, pattern: ${source.pattern.join(', ')}` : ''})`,
+					);
+				}
 				break;
 			}
 		}
@@ -250,11 +181,13 @@ const writeSourceReadme = async (
 };
 
 /**
- * pulls lexicon documents from configured sources and writes them to disk using nsid-based paths.
- * @param config normalized lex-cli configuration
+ * runs the pull command to fetch lexicon documents from configured sources
+ * @param args parsed command arguments
  */
-export const runPull = async (config: NormalizedConfig): Promise<void> => {
+export const runPull = async (args: PullCommand): Promise<void> => {
+	const config = await loadConfig(args.config);
 	const pullConfig = ensurePullConfig(config);
+
 	const outdir = path.resolve(config.root, pullConfig.outdir);
 	const prettierConfig = await prettier.resolveConfig(config.root, { editorconfig: true });
 

package/src/config.ts

@@ -1,10 +1,12 @@
+import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import * as url from 'node:url';
 
 import * as v from '@badrap/valita';
 import pc from 'picocolors';
 
-import { isNsid } from '@atcute/lexicons/syntax';
+import { isAtprotoDid } from '@atcute/identity';
+import { isHandle, isNsid } from '@atcute/lexicons/syntax';
 
 import type { ImportMapping } from './codegen.js';
 
@@ -20,7 +22,32 @@ const gitSourceConfigSchema = v.object({
 		.assert((value) => value.length > 0, `must include at least one glob pattern`),
 });
 
-const sourceConfigSchema = v.union(gitSourceConfigSchema);
+const atprotoNsidsSourceConfigSchema = v.object({
+	type: v.literal('atproto'),
+	mode: v.literal('nsids'),
+	nsids: v
+		.array(v.string().assert((value) => isNsid(value), `must be valid nsid`))
+		.assert((value) => value.length > 0, `must include at least one nsid`),
+});
+
+const atprotoAuthoritySourceConfigSchema = v.object({
+	type: v.literal('atproto'),
+	mode: v.literal('authority'),
+	authority: v
+		.string()
+		.assert((value) => isHandle(value) || isAtprotoDid(value), `must a valid at-identifier`),
+	pattern: v
+		.array(
+			v
+				.string()
+				.assert((value) => isValidLexiconPattern(value), `must be valid nsid or pattern ending with .*`),
+		)
+		.optional(),
+});
+
+const atprotoSourceConfigSchema = v.union(atprotoNsidsSourceConfigSchema, atprotoAuthoritySourceConfigSchema);
+
+const sourceConfigSchema = v.union(gitSourceConfigSchema, atprotoSourceConfigSchema);
 
 const pullConfigSchema = v.object({
 	outdir: v.string().assert((value) => value.length > 0, `must not be empty`),
@@ -30,9 +57,19 @@ const pullConfigSchema = v.object({
 		.assert((value) => value.length > 0, `must include at least one source`),
 });
 
+const exportConfigSchema = v.object({
+	outdir: v.string().assert((value) => value.length > 0, `must not be empty`),
+	files: v.array(v.string().assert((value) => value.length > 0, `must not be empty`)).optional(),
+	clean: v.boolean().optional(),
+});
+
 export type GitSourceConfig = v.Infer<typeof gitSourceConfigSchema>;
+export type AtprotoNsidsSourceConfig = v.Infer<typeof atprotoNsidsSourceConfigSchema>;
+export type AtprotoAuthoritySourceConfig = v.Infer<typeof atprotoAuthoritySourceConfigSchema>;
+export type AtprotoSourceConfig = v.Infer<typeof atprotoSourceConfigSchema>;
 export type SourceConfig = v.Infer<typeof sourceConfigSchema>;
 export type PullConfig = v.Infer<typeof pullConfigSchema>;
+export type ExportConfig = v.Infer<typeof exportConfigSchema>;
 
 const isValidLexiconPattern = (pattern: string): boolean => {
 	if (pattern.endsWith('.*')) {
@@ -90,6 +127,7 @@ export const lexiconConfigSchema = v.object({
 		.partial()
 		.optional(),
 	pull: pullConfigSchema.optional(),
+	export: exportConfigSchema.optional(),
 });
 
 export type LexiconConfig = v.Infer<typeof lexiconConfigSchema>;
@@ -98,8 +136,33 @@ export interface NormalizedConfig extends LexiconConfig {
 	root: string;
 }
 
-export const loadConfig = async (configPath: string): Promise<NormalizedConfig> => {
-	const configFilename = path.resolve(configPath);
+export const loadConfig = async (configPath?: string): Promise<NormalizedConfig> => {
+	let configFilename: string | undefined;
+
+	if (configPath) {
+		configFilename = path.resolve(configPath);
+	} else {
+		// try to find lex.config.js or lex.config.ts in the current directory
+		const candidates = ['lex.config.js', 'lex.config.ts'];
+
+		for (const candidate of candidates) {
+			const candidatePath = path.resolve(candidate);
+			try {
+				await fs.access(candidatePath);
+				configFilename = candidatePath;
+				break;
+			} catch {
+				// file doesn't exist, try next candidate
+			}
+		}
+
+		if (!configFilename) {
+			console.error(pc.bold(pc.red(`config file not found`)));
+			console.error(`looked for: ${candidates.join(', ')}`);
+			process.exit(1);
+		}
+	}
+
 	const configDirname = path.dirname(configFilename);
 
 	let rawConfig: unknown;