@donezone/cli 0.1.0 → 0.1.1

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. */
@@ -13,6 +18,8 @@ program
     // TODO: build contracts
     /*
 
+      Should accept blob pattern.
+
       See how packages/demo/serve.ts handles Bun.build
       
       Output compiled js artifacts to <cwd>/dist folder.
@@ -28,20 +35,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 +58,284 @@ 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 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 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 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,6 +1,6 @@
 {
   "name": "@donezone/cli",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "private": false,
   "type": "module",
   "bin": {