@donezone/cli 0.1.1 → 0.1.2

package/dist/index.js

@@ -13,20 +13,14 @@ program
     .description("Bundle Done contracts defined in done.json")
     .option("-j, --contracts <path>", "Path to done.json")
     .option("-n, --name <name...>", "Filter contract names")
-    .action(() => {
-    notImplemented("build");
-    // TODO: build contracts
-    /*
-
-      Should accept blob pattern.
-
-      See how packages/demo/serve.ts handles Bun.build
-      
-      Output compiled js artifacts to <cwd>/dist folder.
-
-      If cwd is a contract workspace, build all contract packages in workspace.
-
-    */
+    .action(async (options) => {
+    try {
+        await handleBuild(options);
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
 });
 program
     .command("dev")
@@ -81,6 +75,50 @@ async function handleInit(rawName, options) {
     }
     await scaffoldWorkspace(rawName, options);
 }
+async function handleBuild(options) {
+    const manifestInfo = await resolveManifest(options.contracts);
+    const contracts = manifestInfo.manifest.contracts ?? [];
+    if (contracts.length === 0) {
+        throw new Error(`No contracts defined in ${path.relative(process.cwd(), manifestInfo.manifestPath) || manifestInfo.manifestPath}`);
+    }
+    const filters = (options.name ?? [])
+        .flatMap((pattern) => pattern.split(","))
+        .map((pattern) => pattern.trim())
+        .filter(Boolean);
+    const matchers = filters.map(createGlobMatcher);
+    const selected = matchers.length === 0
+        ? contracts
+        : contracts.filter((contract) => matchesContract(contract, manifestInfo.manifestDir, matchers));
+    if (selected.length === 0) {
+        throw new Error(`No contracts matched filters: ${filters.join(", ")}`);
+    }
+    console.log(`Building ${selected.length} contract${selected.length === 1 ? "" : "s"} from ${path.relative(process.cwd(), manifestInfo.manifestPath) || manifestInfo.manifestPath}`);
+    for (const contract of selected) {
+        if (!contract.entry) {
+            throw new Error(`Contract '${contract.name}' is missing an 'entry' path in ${manifestInfo.manifestPath}`);
+        }
+        if (!contract.outFile) {
+            throw new Error(`Contract '${contract.name}' is missing an 'outFile' path in ${manifestInfo.manifestPath}`);
+        }
+        const entryPath = path.resolve(manifestInfo.manifestDir, contract.entry);
+        const outFilePath = path.resolve(manifestInfo.manifestDir, contract.outFile);
+        await ensureEntryExists(entryPath, contract.name);
+        await fs.mkdir(path.dirname(outFilePath), { recursive: true });
+        const relEntry = path.relative(process.cwd(), entryPath) || entryPath;
+        const relOutFile = path.relative(process.cwd(), outFilePath) || outFilePath;
+        console.log(`- bundling ${contract.name} (${relEntry})`);
+        const startedAt = Date.now();
+        try {
+            await runBunBuild(entryPath, outFilePath);
+        }
+        catch (error) {
+            console.error(`[error] failed to build ${contract.name}`);
+            throw error;
+        }
+        const duration = Date.now() - startedAt;
+        console.log(`  [done] ${contract.name} -> ${relOutFile} (${formatDuration(duration)})`);
+    }
+}
 async function detectWorkspace(root) {
     const manifestPath = path.join(root, "done.json");
     const configPath = path.join(root, "done.config.json");
@@ -95,6 +133,50 @@ async function detectWorkspace(root) {
     const config = JSON.parse(configRaw);
     return { root, manifestPath, configPath, manifest, config };
 }
+async function resolveManifest(contractsPathOverride) {
+    if (contractsPathOverride) {
+        const manifestPath = path.resolve(process.cwd(), contractsPathOverride);
+        const manifest = await readManifest(manifestPath);
+        return { manifestPath, manifestDir: path.dirname(manifestPath), manifest };
+    }
+    const workspace = await findWorkspace(process.cwd());
+    if (!workspace) {
+        throw new Error("Unable to find done.json. Run inside a Done workspace or pass --contracts <path>.");
+    }
+    return { manifestPath: workspace.manifestPath, manifestDir: path.dirname(workspace.manifestPath), manifest: workspace.manifest };
+}
+async function findWorkspace(startDir) {
+    let current = path.resolve(startDir);
+    while (true) {
+        const workspace = await detectWorkspace(current);
+        if (workspace) {
+            return workspace;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            return null;
+        }
+        current = parent;
+    }
+}
+async function readManifest(manifestPath) {
+    let raw;
+    try {
+        raw = await fs.readFile(manifestPath, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            throw new Error(`Could not find ${manifestPath}. Pass a valid --contracts path or run from a Done workspace.`);
+        }
+        throw error;
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse ${manifestPath}: ${error.message}`);
+    }
+}
 async function scaffoldWorkspace(rawName, options) {
     const slug = toSlug(rawName);
     if (!slug) {
@@ -302,6 +384,99 @@ function normalizeJsonPath(relativePath) {
     const normalized = relativePath.split(path.sep).join("/");
     return normalized.startsWith("./") || normalized.startsWith("../") ? normalized : `./${normalized}`;
 }
+function matchesContract(contract, manifestDir, matchers) {
+    const candidates = [];
+    if (contract.name) {
+        candidates.push(normalizeMatchValue(contract.name));
+    }
+    if (contract.entry) {
+        candidates.push(normalizeMatchValue(contract.entry));
+        candidates.push(normalizeMatchValue(path.resolve(manifestDir, contract.entry)));
+    }
+    if (contract.outFile) {
+        candidates.push(normalizeMatchValue(contract.outFile));
+        candidates.push(normalizeMatchValue(path.resolve(manifestDir, contract.outFile)));
+    }
+    return matchers.some((matcher) => candidates.some((candidate) => matcher(candidate)));
+}
+function createGlobMatcher(pattern) {
+    const normalized = normalizeMatchValue(pattern);
+    const hasWildcards = /[\*\?]/.test(normalized);
+    if (!hasWildcards) {
+        return (candidate) => normalizeMatchValue(candidate) === normalized;
+    }
+    const escaped = escapeRegExp(normalized)
+        .replace(/\\\*/g, ".*")
+        .replace(/\\\?/g, ".");
+    const regex = new RegExp(`^${escaped}$`);
+    return (candidate) => regex.test(normalizeMatchValue(candidate));
+}
+function normalizeMatchValue(value) {
+    if (!value) {
+        return "";
+    }
+    let normalized = value.replace(/\\/g, "/");
+    if (normalized.startsWith("./")) {
+        normalized = normalized.slice(2);
+    }
+    return normalized;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function ensureEntryExists(entryPath, contractName) {
+    try {
+        const stats = await fs.stat(entryPath);
+        if (!stats.isFile()) {
+            const relPath = path.relative(process.cwd(), entryPath) || entryPath;
+            throw new Error(`Entry path for contract '${contractName}' is not a file (${relPath})`);
+        }
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            const rel = path.relative(process.cwd(), entryPath) || entryPath;
+            throw new Error(`Entry file for contract '${contractName}' not found (${rel})`);
+        }
+        throw error;
+    }
+}
+async function runBunBuild(entryPath, outFilePath) {
+    const bun = getBunRuntime();
+    const result = await bun.build({
+        entrypoints: [entryPath],
+        target: "bun",
+        format: "esm",
+        splitting: false,
+        sourcemap: "none",
+        external: ["bun:*", "node:*"],
+        define: {
+            "process.env.NODE_ENV": '"production"',
+        },
+    });
+    if (!result.success) {
+        const logs = (result.logs ?? []).map((log) => log?.message ?? String(log));
+        throw new Error(logs.join("\n") || "Bun.build failed");
+    }
+    const [output] = result.outputs;
+    if (!output) {
+        throw new Error("Bun.build did not emit an output file");
+    }
+    const bundledSource = await output.text();
+    await fs.writeFile(outFilePath, bundledSource);
+}
+function getBunRuntime() {
+    const bun = globalThis.Bun;
+    if (!bun || typeof bun.build !== "function") {
+        throw new Error("Bun runtime unavailable. Rebuild the done CLI using Bun to embed the runtime.");
+    }
+    return bun;
+}
+function formatDuration(ms) {
+    if (ms < 1000) {
+        return `${ms}ms`;
+    }
+    return `${(ms / 1000).toFixed(2)}s`;
+}
 function toSlug(input) {
     return input
         .trim()

package/package.json

@@ -1,17 +1,18 @@
 {
   "name": "@donezone/cli",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "private": false,
   "type": "module",
   "bin": {
-    "done": "dist/index.js"
+    "done": "dist/done"
   },
   "files": [
     "dist"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "clean": "rimraf dist"
+    "build": "tsc -p tsconfig.json && bun build ./src/index.ts --compile --outfile dist/done",
+    "clean": "rimraf dist",
+    "test": "bun test"
   },
   "dependencies": {
     "@donezone/core": "^0.1.0",