@donezone/cli 0.1.0 → 0.1.2

package/dist/index.js

@@ -1,5 +1,10 @@
 #!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import * as fs from "node:fs/promises";
+import path from "node:path";
 import { Command } from "commander";
+const DEFAULT_TEMPLATE_REPO = "https://github.com/mccallofthewild/done-template.git";
 const program = new Command();
 program.name("done").description("Done developer toolkit (spec-first stub)").version("0.0.0-spec");
 /* NOTE: All of these commands should be expected to be run from a standalone binary, not from the context of this repository / workspace. */
@@ -8,18 +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
-    /*
-
-      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")
@@ -28,20 +29,19 @@ program
     .action(() => notImplemented("dev"));
 program
     .command("init")
-    .description("Set up a new Done project (see SPEC.md)")
-    .action(() => {
-    // TODO: create project template with frontend and backend
-    /*
-
-      Accept first argument for project name (`done init my-project`)
-      Download template, apply naming adjustments etc using whatever
-      JS project template generator library
-
-      Put contents in `my-project` (apply name input) folder
-
-      Install deps, and boot up full stack dev (`done dev`)
-
-    */
+    .argument("[name]", "Project or contract name")
+    .option("-f, --force", "Overwrite existing files if they already exist")
+    .option("--template <repoOrPath>", "Template git repo or local folder (defaults to official Done template)")
+    .option("--no-install", "Skip Bun install after creating a brand new workspace")
+    .description("Set up a new Done workspace or add a contract to an existing workspace")
+    .action(async (rawName, options) => {
+    try {
+        await handleInit(rawName, options);
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
 });
 program
     .command("deploy")
@@ -52,8 +52,465 @@ program
 program
     .command("test")
     .description("Run unit tests for contracts");
-program.parseAsync().catch((error) => notImplemented(error instanceof Error ? error.message : String(error)));
+program.parseAsync().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});
 function notImplemented(label) {
     console.error(`The command segment '${label}' is not implemented yet.\nSee packages/done-cli/SPEC.md for the planned behaviour.`);
     process.exit(1);
 }
+async function handleInit(rawName, options) {
+    const cwd = process.cwd();
+    const workspace = await detectWorkspace(cwd);
+    if (workspace) {
+        if (!rawName) {
+            throw new Error("Contract name is required when running init inside an existing Done workspace.");
+        }
+        await scaffoldContract(workspace, rawName, options);
+        return;
+    }
+    if (!rawName) {
+        throw new Error("Project name is required when creating a brand new Done workspace.");
+    }
+    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");
+    if (!existsSync(manifestPath) || !existsSync(configPath)) {
+        return null;
+    }
+    const [manifestRaw, configRaw] = await Promise.all([
+        fs.readFile(manifestPath, "utf8"),
+        fs.readFile(configPath, "utf8"),
+    ]);
+    const manifest = JSON.parse(manifestRaw);
+    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) {
+        throw new Error(`Could not derive a valid directory name from '${rawName}'.`);
+    }
+    const templateRef = options.template ?? DEFAULT_TEMPLATE_REPO;
+    const cwd = process.cwd();
+    const targetDir = path.resolve(cwd, slug);
+    await prepareTargetDir(targetDir, options.force === true);
+    const localTemplatePath = await resolveLocalTemplate(templateRef);
+    if (localTemplatePath) {
+        await fs.cp(localTemplatePath, targetDir, { recursive: true });
+    }
+    else {
+        await runCommand("git", ["clone", "--depth", "1", templateRef, targetDir]);
+    }
+    await removeGitFolder(targetDir);
+    await updatePackageJson(path.join(targetDir, "package.json"), (pkg) => {
+        pkg.name = slug;
+    });
+    await updatePackageJson(path.join(targetDir, "frontend", "package.json"), (pkg) => {
+        pkg.name = `${slug}-frontend`;
+    });
+    if (options.install !== false) {
+        await runCommand("bun", ["install"], { cwd: targetDir });
+    }
+    console.log(`Done workspace created at ${path.relative(cwd, targetDir) || "."}.`);
+    console.log("Next steps:");
+    console.log(`  cd ${path.relative(cwd, targetDir) || slug}`);
+    if (options.install === false) {
+        console.log("  bun install");
+    }
+    console.log("  bunx done dev");
+}
+async function scaffoldContract(workspace, rawName, options) {
+    const slug = toSlug(rawName);
+    if (!slug) {
+        throw new Error(`Could not derive a valid contract directory name from '${rawName}'.`);
+    }
+    const contractName = toContractName(slug);
+    const contractsDir = resolveContractsDir(workspace.root, workspace.config.contractsDir);
+    const contractDir = path.join(contractsDir, slug);
+    await ensureDirAvailable(contractDir, options.force === true);
+    await fs.mkdir(path.join(contractDir, "src"), { recursive: true });
+    const pkgJsonPath = path.join(contractDir, "package.json");
+    const pkgJson = {
+        name: slug,
+        version: "0.1.0",
+        private: true,
+        type: "module",
+        scripts: {
+            typecheck: "tsc -p tsconfig.json --noEmit",
+        },
+        dependencies: {
+            "@donezone/contract-types": "^0.1.0",
+        },
+    };
+    await writeJson(pkgJsonPath, pkgJson);
+    const rootTsconfig = path.join(workspace.root, "tsconfig.json");
+    const tsconfig = {
+        compilerOptions: {
+            module: "ESNext",
+            moduleResolution: "bundler",
+            target: "ES2022",
+            isolatedModules: true,
+            noEmit: true,
+        },
+        include: ["src/**/*.ts"],
+    };
+    if (existsSync(rootTsconfig)) {
+        tsconfig.extends = normalizeJsonPath(path.relative(contractDir, rootTsconfig));
+    }
+    await writeJson(path.join(contractDir, "tsconfig.json"), tsconfig);
+    const storeKey = `${slug}-greeting`;
+    const defaultGreeting = `Hello from ${contractName}`;
+    const contractSource = `const Greeting = Done.item<string>("${storeKey}");
+
+interface SetGreetingBody {
+  greeting: string;
+}
+
+export default Done.serve()
+  .instantiate(async () => {
+    const existing = await Greeting.load();
+    if (!existing) {
+      await Greeting.save("${defaultGreeting}");
+    }
+  })
+  .query("/greeting", async () => {
+    const greeting = await Greeting.load();
+    return { greeting: greeting ?? "${defaultGreeting}" };
+  })
+  .transaction(
+    "/greeting",
+    async ({ body }) => {
+      const payload = (body ?? {}) as Partial<SetGreetingBody>;
+      const next = payload.greeting?.trim();
+
+      if (!next) {
+        throw new Error("greeting text required");
+      }
+
+      await Greeting.save(next);
+      return { greeting: next };
+    },
+    {
+      body: {
+        type: "object",
+        properties: {
+          greeting: { type: "string", minLength: 1, maxLength: 280 },
+        },
+        required: ["greeting"],
+        additionalProperties: false,
+      },
+    },
+  );
+`;
+    await fs.writeFile(path.join(contractDir, "src", "index.ts"), contractSource, "utf8");
+    workspace.manifest.contracts ??= [];
+    const contractDirRel = normalizeJsonPath(path.relative(workspace.root, contractDir));
+    const entry = ensureDotSlash(`${contractDirRel}/src/index.ts`);
+    const outFile = ensureDotSlash(`${contractDirRel}/dist/${slug}.contract.js`);
+    const watch = [ensureDotSlash(`${contractDirRel}/src/**/*.ts`)];
+    const newEntry = {
+        name: contractName,
+        entry,
+        outFile,
+        watch,
+        instantiate: { admin: null },
+    };
+    const existingIndex = workspace.manifest.contracts.findIndex((contract) => contract.name === contractName);
+    if (existingIndex >= 0 && options.force !== true) {
+        throw new Error(`Contract '${contractName}' already exists in done.json. Use --force to replace it.`);
+    }
+    if (existingIndex >= 0) {
+        workspace.manifest.contracts[existingIndex] = newEntry;
+    }
+    else {
+        workspace.manifest.contracts.push(newEntry);
+    }
+    await writeJson(workspace.manifestPath, workspace.manifest);
+    console.log(`Created Done contract '${contractName}' in ${path.relative(workspace.root, contractDir)}`);
+    console.log("Next steps:");
+    console.log("  bunx done build --name", contractName);
+    console.log("  bunx done dev");
+}
+async function resolveLocalTemplate(reference) {
+    const potentialPath = path.isAbsolute(reference) ? reference : path.resolve(process.cwd(), reference);
+    try {
+        const stats = await fs.stat(potentialPath);
+        if (stats.isDirectory()) {
+            return potentialPath;
+        }
+    }
+    catch { }
+    return null;
+}
+async function prepareTargetDir(targetDir, force) {
+    if (!existsSync(targetDir)) {
+        return;
+    }
+    if (!force) {
+        throw new Error(`Directory '${path.relative(process.cwd(), targetDir) || targetDir}' already exists. Use --force to overwrite.`);
+    }
+    await fs.rm(targetDir, { recursive: true, force: true });
+}
+async function ensureDirAvailable(targetDir, force) {
+    if (!existsSync(targetDir)) {
+        return;
+    }
+    if (!force) {
+        throw new Error(`Directory '${path.relative(process.cwd(), targetDir) || targetDir}' already exists. Use --force to overwrite.`);
+    }
+    await fs.rm(targetDir, { recursive: true, force: true });
+}
+async function removeGitFolder(targetDir) {
+    await fs.rm(path.join(targetDir, ".git"), { recursive: true, force: true });
+}
+function resolveContractsDir(root, configured) {
+    if (!configured) {
+        return path.join(root, "contracts");
+    }
+    if (path.isAbsolute(configured)) {
+        return configured;
+    }
+    return path.resolve(root, configured);
+}
+async function updatePackageJson(file, mutator) {
+    try {
+        const current = JSON.parse(await fs.readFile(file, "utf8"));
+        mutator(current);
+        await writeJson(file, current);
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return;
+        }
+        throw error;
+    }
+}
+function ensureDotSlash(value) {
+    return value.startsWith("./") || value.startsWith("../") ? value : `./${value}`;
+}
+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()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+/, "")
+        .replace(/-+$/, "");
+}
+function toContractName(slug) {
+    const parts = slug.split(/[^a-zA-Z0-9]+/).filter(Boolean);
+    if (parts.length === 0) {
+        return "contract";
+    }
+    const [first, ...rest] = parts;
+    return first + rest.map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+async function writeJson(file, data) {
+    const json = JSON.stringify(data, null, 2);
+    await fs.writeFile(file, `${json}\n`, "utf8");
+}
+async function runCommand(command, args, options = {}) {
+    await new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            cwd: options.cwd,
+            stdio: "inherit",
+        });
+        child.on("close", (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`${command} ${args.join(" ")} failed with exit code ${code}`));
+            }
+        });
+        child.on("error", (error) => reject(error));
+    });
+}

package/package.json

@@ -1,17 +1,18 @@
 {
   "name": "@donezone/cli",
-  "version": "0.1.0",
+  "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",