create-lapis-lazuli 0.1.0

package/dist/index.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+import { basename } from "node:path";
+import { buildProject, bundleProject, createProject, validateManifest } from "./lib.js";
+function usage() {
+    throw new Error([
+        "Usage:",
+        "  create-lapis-lazuli <directory> [display-name] [engine]",
+        "  lapis create <directory> [display-name] [engine]",
+        "  lapis validate <directory>",
+        "  lapis bundle <directory> [output-directory]",
+        "  lapis build <directory>",
+        "",
+        "Supported engines: js, python",
+    ].join("\n"));
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const executable = basename(process.argv[1] ?? "");
+    const knownCommands = new Set(["create", "validate", "build", "bundle"]);
+    let [command, firstArg, secondArg, thirdArg] = args;
+    if (executable === "create-lapis-lazuli" && (!command || !knownCommands.has(command))) {
+        thirdArg = secondArg;
+        secondArg = firstArg;
+        firstArg = command;
+        command = "create";
+    }
+    if (!command) {
+        usage();
+    }
+    switch (command) {
+        case "create": {
+            if (!firstArg) {
+                usage();
+            }
+            const result = await createProject(firstArg, secondArg, thirdArg);
+            console.log(`Created ${result.projectDir}`);
+            return;
+        }
+        case "validate":
+            {
+                if (!firstArg) {
+                    usage();
+                }
+                const result = await validateManifest(firstArg);
+                console.log(`Validated ${result.manifest.id} -> ${result.entrypoint}`);
+                return;
+            }
+        case "build": {
+            if (!firstArg) {
+                usage();
+            }
+            const result = await buildProject(firstArg);
+            console.log(`Built ${result.manifest.id} -> ${result.buildDir}`);
+            return;
+        }
+        case "bundle": {
+            if (!firstArg) {
+                usage();
+            }
+            const result = await bundleProject(firstArg, secondArg);
+            console.log(`Bundled ${result.bundleDir}`);
+            return;
+        }
+        default:
+            usage();
+    }
+}
+main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+});

package/dist/lib.js

@@ -0,0 +1,267 @@
+import { copyFile, lstat, mkdir, mkdtemp, readFile, readdir, rm, stat, symlink, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { renderManifest, renderPackageJson, renderPythonPyproject, renderSource, GITIGNORE } from "./templates.js";
+const LOCAL_SDK_DIR = fileURLToPath(new URL("../../../sdks/typescript", import.meta.url));
+const LOCAL_PYTHON_SDK_DIR = fileURLToPath(new URL("../../../sdks/python/src/lapis_lazuli", import.meta.url));
+const SUPPORTED_ENGINES = new Set(["js", "python"]);
+const PYTHON_BUNDLE_IGNORED_DIRECTORIES = new Set([
+    ".git",
+    ".lapis",
+    "__pycache__",
+    ".mypy_cache",
+    ".pytest_cache",
+    ".ruff_cache",
+    ".venv",
+    "dist",
+    "node_modules",
+    "venv",
+]);
+const PYTHON_BUNDLE_IGNORED_FILES = new Set([
+    ".DS_Store",
+]);
+function assertString(value, field) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`Manifest field "${field}" must be a non-empty string.`);
+    }
+    return value;
+}
+export async function readManifest(projectDir) {
+    const manifestPath = join(resolve(projectDir), "lapis-plugin.json");
+    const manifestText = await readFile(manifestPath, "utf8");
+    const raw = JSON.parse(manifestText);
+    return {
+        id: assertString(raw.id, "id"),
+        name: assertString(raw.name, "name"),
+        version: assertString(raw.version, "version"),
+        engine: assertString(raw.engine, "engine"),
+        main: assertString(raw.main, "main"),
+        apiVersion: assertString(raw.apiVersion, "apiVersion"),
+    };
+}
+export async function validateManifest(projectDir) {
+    const manifest = await readManifest(projectDir);
+    const entrypoint = resolve(projectDir, manifest.main);
+    const entrypointStats = await stat(entrypoint).catch(() => null);
+    if (!entrypointStats?.isFile()) {
+        throw new Error(`Entrypoint "${manifest.main}" does not exist.`);
+    }
+    assertSupportedEngine(manifest.engine);
+    return {
+        manifest,
+        entrypoint,
+    };
+}
+export async function buildProject(projectDir) {
+    const { manifest, entrypoint } = await validateManifest(projectDir);
+    const buildDir = resolve(projectDir, ".lapis/build");
+    await rm(buildDir, { recursive: true, force: true });
+    await mkdir(buildDir, { recursive: true });
+    if (manifest.engine === "js") {
+        const cleanupLocalSdkLink = await ensureLocalSdkLink(projectDir);
+        const preparedEntrypoint = await prepareEntrypointForBuild(entrypoint);
+        try {
+            const result = await Bun.build({
+                entrypoints: [preparedEntrypoint.entrypoint],
+                root: resolve(projectDir),
+                outdir: buildDir,
+                target: "node",
+                format: "cjs",
+                sourcemap: "external",
+                minify: false,
+                splitting: false,
+            });
+            if (!result.success) {
+                const logs = result.logs.map((log) => log.message).join("\n");
+                throw new Error(`Build failed.\n${logs}`);
+            }
+        }
+        finally {
+            await preparedEntrypoint.cleanup?.();
+            await cleanupLocalSdkLink?.();
+        }
+    }
+    else {
+        await stagePythonProject(projectDir, buildDir);
+    }
+    return {
+        buildDir,
+        manifest,
+    };
+}
+export async function bundleProject(projectDir, outputDir) {
+    const { buildDir, manifest } = await buildProject(projectDir);
+    const bundleDir = resolve(outputDir ?? join(projectDir, "dist", manifest.id));
+    const bundledMain = manifest.engine === "js" ? "main.js" : normalizeBundlePath(manifest.main);
+    const mainPath = join(bundleDir, bundledMain);
+    const manifestPath = join(bundleDir, "lapis-plugin.json");
+    await rm(bundleDir, { recursive: true, force: true });
+    await mkdir(bundleDir, { recursive: true });
+    if (manifest.engine === "js") {
+        const builtMain = await findBuiltEntrypoint(buildDir);
+        if (!builtMain) {
+            throw new Error("Bundled output did not contain a JavaScript entrypoint.");
+        }
+        const builtContents = await readFile(builtMain, "utf8");
+        await mkdir(dirname(mainPath), { recursive: true });
+        await writeFile(mainPath, builtContents, "utf8");
+    }
+    else {
+        await copyDirectoryContents(buildDir, bundleDir);
+    }
+    await writeFile(manifestPath, JSON.stringify({
+        ...manifest,
+        main: bundledMain,
+    }, null, 2), "utf8");
+    return {
+        bundleDir,
+        manifestPath,
+        mainPath,
+    };
+}
+export async function createProject(destination, displayName, engine = "js") {
+    const projectDir = resolve(destination);
+    const id = basename(projectDir);
+    const supportedEngine = assertSupportedEngine(engine);
+    const pluginName = displayName ?? id
+        .split(/[-_]/g)
+        .filter(Boolean)
+        .map((part) => part[0].toUpperCase() + part.slice(1))
+        .join(" ");
+    await mkdir(join(projectDir, "src"), { recursive: true });
+    if (supportedEngine === "js") {
+        await writeFile(join(projectDir, "package.json"), renderPackageJson(id), "utf8");
+    }
+    else {
+        await writeFile(join(projectDir, "pyproject.toml"), renderPythonPyproject(id), "utf8");
+    }
+    await writeFile(join(projectDir, "lapis-plugin.json"), renderManifest(id, pluginName, supportedEngine), "utf8");
+    await writeFile(join(projectDir, "src", supportedEngine === "js" ? "index.ts" : "main.py"), renderSource(pluginName, supportedEngine), "utf8");
+    await writeFile(join(projectDir, ".gitignore"), GITIGNORE, "utf8");
+    return { projectDir };
+}
+export async function createTempProject(prefix = "lapis-cli-test-") {
+    return mkdtemp(join(tmpdir(), prefix));
+}
+export async function cleanupTempProject(projectDir) {
+    await rm(resolve(projectDir), { recursive: true, force: true });
+}
+export async function ensureDirectory(path) {
+    await mkdir(resolve(path), { recursive: true });
+}
+export async function writeTextFile(path, contents) {
+    await ensureDirectory(dirname(path));
+    await writeFile(path, contents, "utf8");
+}
+async function ensureLocalSdkLink(projectDir) {
+    const linkPath = join(resolve(projectDir), "node_modules", "lapis-lazuli");
+    const existing = await lstat(linkPath).catch(() => null);
+    if (existing) {
+        return null;
+    }
+    const localSdkExists = await stat(LOCAL_SDK_DIR).catch(() => null);
+    if (!localSdkExists?.isDirectory()) {
+        return null;
+    }
+    await mkdir(dirname(linkPath), { recursive: true });
+    await symlink(LOCAL_SDK_DIR, linkPath, "dir");
+    return async () => {
+        await rm(linkPath, { recursive: true, force: true });
+    };
+}
+async function prepareEntrypointForBuild(entrypoint) {
+    const source = await readFile(entrypoint, "utf8");
+    const localSdkEntry = join(LOCAL_SDK_DIR, "src", "index.ts");
+    const localSdkExists = await stat(localSdkEntry).catch(() => null);
+    if (!localSdkExists?.isFile() || !source.includes("lapis-lazuli")) {
+        return { entrypoint };
+    }
+    const rewrittenImportPath = normalizeImportPath(relative(dirname(entrypoint), localSdkEntry));
+    const rewrittenSource = source.replace(/(["'])lapis-lazuli\1/g, (_match, quote) => `${quote}${rewrittenImportPath}${quote}`);
+    const rewrittenEntrypoint = join(dirname(entrypoint), `.lapis-${basename(entrypoint)}`);
+    await writeFile(rewrittenEntrypoint, rewrittenSource, "utf8");
+    return {
+        entrypoint: rewrittenEntrypoint,
+        cleanup: async () => {
+            await rm(rewrittenEntrypoint, { force: true });
+        },
+    };
+}
+function normalizeImportPath(importPath) {
+    const normalized = importPath.replaceAll("\\", "/");
+    return normalized.startsWith(".") ? normalized : `./${normalized}`;
+}
+async function findBuiltEntrypoint(buildDir) {
+    const entries = await readdir(buildDir, { withFileTypes: true });
+    for (const entry of entries) {
+        const absolutePath = join(buildDir, entry.name);
+        if (entry.isDirectory()) {
+            const nested = await findBuiltEntrypoint(absolutePath);
+            if (nested) {
+                return nested;
+            }
+            continue;
+        }
+        if (entry.isFile() && entry.name.endsWith(".js") && !entry.name.endsWith(".js.map")) {
+            return absolutePath;
+        }
+    }
+    return null;
+}
+function assertSupportedEngine(engine) {
+    if (!SUPPORTED_ENGINES.has(engine)) {
+        throw new Error(`Unsupported engine "${engine}". Supported engines: ${Array.from(SUPPORTED_ENGINES).map((value) => `"${value}"`).join(", ")}.`);
+    }
+    return engine;
+}
+function normalizeBundlePath(path) {
+    return path.replaceAll("\\", "/").replace(/^\.\//, "");
+}
+async function stagePythonProject(projectDir, buildDir) {
+    await copyDirectoryContents(resolve(projectDir), buildDir, shouldIncludePythonBundlePath);
+    await ensureLocalPythonSdk(buildDir);
+}
+function shouldIncludePythonBundlePath(relativePath, entry) {
+    void relativePath;
+    if (entry.isDirectory()) {
+        return !PYTHON_BUNDLE_IGNORED_DIRECTORIES.has(entry.name);
+    }
+    return !PYTHON_BUNDLE_IGNORED_FILES.has(entry.name);
+}
+async function copyDirectoryContents(sourceDir, targetDir, shouldInclude = () => true) {
+    async function visit(currentSourceDir) {
+        const entries = await readdir(currentSourceDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const sourcePath = join(currentSourceDir, entry.name);
+            const relativePath = normalizeBundlePath(relative(sourceDir, sourcePath));
+            if (!shouldInclude(relativePath, entry)) {
+                continue;
+            }
+            const targetPath = join(targetDir, relativePath);
+            if (entry.isDirectory()) {
+                await mkdir(targetPath, { recursive: true });
+                await visit(sourcePath);
+                continue;
+            }
+            if (entry.isFile()) {
+                await mkdir(dirname(targetPath), { recursive: true });
+                await copyFile(sourcePath, targetPath);
+            }
+        }
+    }
+    await visit(sourceDir);
+}
+async function ensureLocalPythonSdk(buildDir) {
+    const localSdkExists = await stat(LOCAL_PYTHON_SDK_DIR).catch(() => null);
+    if (!localSdkExists?.isDirectory()) {
+        return;
+    }
+    const targetDir = join(buildDir, "lapis_lazuli");
+    const existingTarget = await stat(targetDir).catch(() => null);
+    if (existingTarget?.isDirectory()) {
+        return;
+    }
+    await mkdir(targetDir, { recursive: true });
+    await copyDirectoryContents(LOCAL_PYTHON_SDK_DIR, targetDir);
+}

package/dist/templates.js

@@ -0,0 +1,95 @@
+export function renderPackageJson(name) {
+    return JSON.stringify({
+        name,
+        private: true,
+        type: "module",
+        scripts: {
+            build: "lapis build .",
+            bundle: "lapis bundle .",
+        },
+        dependencies: {
+            "lapis-lazuli": "^0.1.0",
+        },
+    }, null, 2);
+}
+export function renderPythonPyproject(name) {
+    return [
+        "[project]",
+        `name = "${name}"`,
+        'version = "0.1.0"',
+        'description = "Lapis Lazuli Python plugin"',
+        'requires-python = ">=3.11"',
+        "dependencies = [",
+        '  "lapis-lazuli-sdk>=0.1.0",',
+        "]",
+        "",
+    ].join("\n");
+}
+export function renderManifest(id, displayName, engine = "js") {
+    return JSON.stringify({
+        id,
+        name: displayName,
+        version: "0.1.0",
+        engine,
+        main: engine === "js" ? "./src/index.ts" : "./src/main.py",
+        apiVersion: "1.0",
+    }, null, 2);
+}
+export function renderSource(displayName, engine = "js") {
+    if (engine === "python") {
+        return `from lapis_lazuli import Plugin
+
+plugin = Plugin("${displayName}", version="0.1.0")
+
+
+@plugin.startup
+def on_enable(context):
+    context.app.log.info("${displayName} enabled.")
+
+    def execute(command):
+        command.sender.send_message("Hello from ${displayName}.")
+
+    context.commands.register(
+        "hello",
+        execute,
+        description="Send a hello message from ${displayName}.",
+    )
+
+
+@plugin.shutdown
+def on_disable(context):
+    context.app.log.info("${displayName} disabled.")
+`;
+    }
+    return `import { definePlugin } from "lapis-lazuli";
+
+export default definePlugin({
+  name: "${displayName}",
+  version: "0.1.0",
+  onEnable(context) {
+    context.app.log.info("${displayName} enabled.");
+
+    context.commands.register({
+      name: "hello",
+      description: "Send a hello message from ${displayName}.",
+      execute({ sender }) {
+        sender.sendMessage("Hello from ${displayName}.");
+      },
+    });
+  },
+  onDisable(context) {
+    context.app.log.info("${displayName} disabled.");
+  },
+});
+`;
+}
+export const GITIGNORE = `dist
+.lapis
+node_modules
+.venv
+venv
+__pycache__
+.mypy_cache
+.pytest_cache
+.ruff_cache
+`;

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "create-lapis-lazuli",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "bin": {
+    "create-lapis-lazuli": "./dist/index.js",
+    "lapis": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepublishOnly": "bun run build",
+    "test": "bun test"
+  },
+  "devDependencies": {
+    "@types/node": "^24.5.2",
+    "typescript": "^5.9.3"
+  }
+}