aiex-cli 0.0.1-beta.3 → 0.0.1-beta.31

package/dist/completions-C3rmTwXZ.mjs

@@ -0,0 +1,90 @@
+import path from "node:path";
+import process from "node:process";
+import { readFileSync } from "jsonfile";
+import fs from "node:fs";
+
+//#region src/core/completions.ts
+const LEADING_DASHES = /^-+/;
+function getArgNames(cmd) {
+	if (!cmd.args) return [];
+	return Object.entries(cmd.args).flatMap(([key, arg]) => {
+		const names = [`--${key}`];
+		if (arg.alias) names.push(`-${arg.alias}`);
+		return names;
+	});
+}
+function getCommandNames(cmds) {
+	return Object.keys(cmds).filter((c) => !c.startsWith("_"));
+}
+function getFileCompletions(pattern) {
+	try {
+		const files = fs.readdirSync(path.dirname(pattern));
+		const ext = path.extname(pattern);
+		const prefix = path.basename(pattern).replace(ext, "");
+		return files.filter((f) => f.endsWith(ext) && f.startsWith(prefix)).map((f) => f.replace(ext, ""));
+	} catch {
+		return [];
+	}
+}
+function getJsonModelNames(configPath) {
+	try {
+		const config = readFileSync(configPath);
+		if (config.provider?.models) return config.provider.models.map((m) => m.name);
+	} catch {}
+	return [];
+}
+function getValueCompletions(prevArg) {
+	switch (prevArg) {
+		case "--schema":
+		case "-s": {
+			const cwd = process.cwd();
+			return getFileCompletions(path.join(cwd, ".aiex/schema/*.json"));
+		}
+		case "--model":
+		case "-m": {
+			const cwd = process.cwd();
+			return getJsonModelNames(path.join(cwd, ".aiex/ai-config.json"));
+		}
+		case "--file":
+		case "-f":
+		case "--text":
+		case "-t":
+		case "--name":
+		case "--port":
+		case "-p": return [];
+		default: return [];
+	}
+}
+function getCompletions(subCommands, args) {
+	const cmds = getCommandNames(subCommands);
+	if (args.length <= 1) {
+		const word = args[0] ?? "";
+		if (!word) return cmds;
+		return cmds.filter((c) => c.startsWith(word));
+	}
+	const cmdName = args[0];
+	const cmd = subCommands[cmdName];
+	const rest = args.slice(1);
+	if (!cmd) {
+		const matched = cmds.filter((c) => c.startsWith(cmdName));
+		if (matched.length > 0) return matched;
+		return cmds;
+	}
+	const current = rest[rest.length - 1] ?? "";
+	const prev = rest.length > 1 ? rest[rest.length - 2] : void 0;
+	if (current.startsWith("-")) {
+		const names = getArgNames(cmd);
+		if (!current) return names;
+		const key = current.replace(LEADING_DASHES, "");
+		if (!key) return names;
+		return names.filter((n) => n.replace(LEADING_DASHES, "").startsWith(key));
+	}
+	if (!current && prev) {
+		const values = getValueCompletions(prev);
+		if (values.length > 0) return values;
+	}
+	return getArgNames(cmd);
+}
+
+//#endregion
+export { getCompletions };

package/dist/core/schema-sqlite/migrate-helper.mjs

@@ -1,11 +1,20 @@
 import { createRequire } from "node:module";
+import fs from "node:fs/promises";
 import path from "node:path";
 import process from "node:process";
+import { readFile, writeFile } from "jsonfile";
 import { fileURLToPath } from "node:url";
-import fs from "node:fs/promises";
 import Database from "better-sqlite3";
 import * as esbuild from "esbuild";
+import lockfile from "proper-lockfile";
+
+//#region src/core/schema-sqlite/migration-name.ts
+function sanitizeMigrationName(name) {
+	if (!name) return void 0;
+	return name.trim().toLowerCase().replace(/[^a-z0-9_\s-]/g, "_").replace(/[\s-]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "") || void 0;
+}
 
+//#endregion
 //#region src/core/schema-sqlite/migrate-helper.ts
 const require = createRequire(import.meta.url);
 const __filename = fileURLToPath(import.meta.url);
@@ -55,22 +64,21 @@ async function loadSchemaExports(schemaPath) {
 async function loadPrevSnapshot(migrationsPath) {
 	const metaPath = path.join(migrationsPath, "meta", "_journal.json");
 	try {
-		const journal = JSON.parse(await fs.readFile(metaPath, "utf-8"));
+		const journal = await readFile(metaPath);
 		if (!journal.entries?.length) return null;
 		const latestEntry = journal.entries[journal.entries.length - 1];
-		const snapshotPath = path.join(migrationsPath, "meta", `${latestEntry.tag}_snapshot.json`);
-		return JSON.parse(await fs.readFile(snapshotPath, "utf-8"));
+		return await readFile(path.join(migrationsPath, "meta", `${latestEntry.tag}_snapshot.json`));
 	} catch {
 		return null;
 	}
 }
-async function saveSnapshot(migrationsPath, snapshot) {
+async function saveSnapshot(migrationsPath, snapshot, migrationName) {
 	const metaPath = path.join(migrationsPath, "meta");
 	await fs.mkdir(metaPath, { recursive: true });
 	const journalPath = path.join(metaPath, "_journal.json");
 	let journal;
 	try {
-		journal = JSON.parse(await fs.readFile(journalPath, "utf-8"));
+		journal = await readFile(journalPath);
 	} catch {
 		journal = {
 			version: "6",
@@ -79,9 +87,12 @@ async function saveSnapshot(migrationsPath, snapshot) {
 		};
 	}
 	const idx = journal.entries.length + 1;
-	const tag = `${String(idx).padStart(4, "0")}_${snapshot.id.replace(/-/g, "_").substring(0, 8)}`;
-	const snapshotPath = path.join(metaPath, `${tag}_snapshot.json`);
-	await fs.writeFile(snapshotPath, JSON.stringify(snapshot, null, 2));
+	const suffix = sanitizeMigrationName(migrationName) || snapshot.id.replace(/-/g, "_").substring(0, 8);
+	const tag = `${String(idx).padStart(4, "0")}_${suffix}`;
+	await writeFile(path.join(metaPath, `${tag}_snapshot.json`), snapshot, {
+		spaces: 2,
+		EOL: "\n"
+	});
 	journal.entries.push({
 		idx,
 		version: snapshot.id,
@@ -89,7 +100,10 @@ async function saveSnapshot(migrationsPath, snapshot) {
 		tag,
 		breakpoints: true
 	});
-	await fs.writeFile(journalPath, JSON.stringify(journal, null, 2));
+	await writeFile(journalPath, journal, {
+		spaces: 2,
+		EOL: "\n"
+	});
 	return tag;
 }
 async function saveMigrationFile(migrationsPath, tag, sqlStatements) {
@@ -111,50 +125,43 @@ function applyMigrationWithTransaction(dbPath, sqlStatements) {
 	}
 }
 const LOCK_FILE = ".migrate.lock";
-async function acquireLock(aiexDir) {
-	const lockPath = path.join(aiexDir, LOCK_FILE);
+async function acquireMigrationLock(aiexDir) {
 	await fs.mkdir(aiexDir, { recursive: true });
 	try {
-		const fd = await fs.open(lockPath, "wx");
-		await fd.write(`${process.pid}\n${Date.now()}`);
-		await fd.close();
-	} catch (e) {
-		if (e.code === "EEXIST") try {
-			const [pidStr, timestampStr] = (await fs.readFile(lockPath, "utf-8")).split("\n");
-			const lockPid = Number.parseInt(pidStr, 10);
-			const lockTime = Number.parseInt(timestampStr, 10);
-			const lockAge = Date.now() - lockTime;
-			if (lockAge > 3e5) {
-				await fs.unlink(lockPath);
-				return acquireLock(aiexDir);
-			}
-			throw new Error(`Migration is already running (PID ${lockPid}, started ${Math.round(lockAge / 1e3)}s ago). Wait for it to complete or remove ${lockPath} if stale.`);
-		} catch {
-			await fs.unlink(lockPath).catch(() => {});
-			return acquireLock(aiexDir);
-		}
-		throw e;
+		return await lockfile.lock(aiexDir, {
+			lockfilePath: path.join(aiexDir, LOCK_FILE),
+			realpath: false,
+			stale: 3e5,
+			update: 1e4,
+			retries: 0
+		});
+	} catch (error) {
+		const lockPath = path.join(aiexDir, LOCK_FILE);
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`Migration is already running or the lock could not be acquired. Wait for it to complete or remove ${lockPath} if stale. ${message}`);
 	}
 }
-async function releaseLock(aiexDir) {
-	const lockPath = path.join(aiexDir, LOCK_FILE);
-	await fs.unlink(lockPath).catch(() => {});
-}
 async function main() {
 	const args = process.argv.slice(2);
 	const schemaPath = args[0];
 	const migrationsPath = args[1];
 	const dbPath = args[2];
+	const migrationName = args[3];
 	if (!schemaPath || !migrationsPath || !dbPath) {
-		console.error("Usage: migrate-helper.ts <schemaPath> <migrationsPath> <dbPath>");
+		console.error("Usage: migrate-helper.ts <schemaPath> <migrationsPath> <dbPath> [migrationName]");
 		process.exit(1);
 	}
 	try {
-		const aiexDir = path.dirname(path.dirname(migrationsPath));
-		await acquireLock(aiexDir);
+		const releaseLock = await acquireMigrationLock(path.dirname(path.dirname(migrationsPath)));
 		try {
 			const exports = await loadSchemaExports(schemaPath);
-			const prevSnapshot = await loadPrevSnapshot(migrationsPath);
+			let dbMissing = false;
+			try {
+				await fs.access(dbPath);
+			} catch {
+				dbMissing = true;
+			}
+			const prevSnapshot = dbMissing ? null : await loadPrevSnapshot(migrationsPath);
 			const currentSnapshot = await generateSQLiteDrizzleJson(exports, prevSnapshot?.id);
 			const sqlStatements = await generateSQLiteMigration(prevSnapshot || EMPTY_SNAPSHOT, currentSnapshot);
 			if (sqlStatements.length === 0) {
@@ -165,7 +172,7 @@ async function main() {
 				return;
 			}
 			applyMigrationWithTransaction(dbPath, sqlStatements);
-			const tag = await saveSnapshot(migrationsPath, currentSnapshot);
+			const tag = await saveSnapshot(migrationsPath, currentSnapshot, migrationName);
 			await saveMigrationFile(migrationsPath, tag, sqlStatements);
 			console.log(JSON.stringify({
 				success: true,
@@ -173,7 +180,7 @@ async function main() {
 				tag
 			}));
 		} finally {
-			await releaseLock(aiexDir);
+			await releaseLock();
 		}
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
@@ -184,7 +191,7 @@ async function main() {
 		process.exit(1);
 	}
 }
-main();
+if (process.argv[1] && __filename === path.resolve(process.argv[1])) main();
 
 //#endregion
 export {  };