@clarigen/cli 3.1.0 → 3.2.0

package/dist/run-cli.js

@@ -7,7 +7,7 @@ import { Cli, Builtins } from "clipanion";
 import { Command as Command2, Option as Option2 } from "clipanion";
 
 // src/config.ts
-import { z as z2 } from "zod";
+import { type as type2 } from "arktype";
 
 // src/logger.ts
 import { pino } from "pino";
@@ -57,19 +57,27 @@ function sortContracts(contracts) {
 }
 
 // src/clarinet-config.ts
-import { z } from "zod";
+import { type } from "arktype";
 import { readFile } from "fs/promises";
 import { parse } from "@iarna/toml";
-var ClarinetConfigSchema = z.object({
-  project: z.object({
-    requirements: z.array(z.object({ contract_id: z.string() })).optional(),
-    cache_location: z.object({ path: z.string() }).optional()
+var ClarinetConfig = type({
+  project: type({
+    requirements: type({
+      contract_id: type("string").describe("Contract ID")
+    }).array().describe("Project requirements").optional(),
+    cache_location: type({
+      path: type("string").describe("Cache location path")
+    }).optional()
   }),
-  contracts: z.record(z.string(), z.object({ path: z.string() })).optional()
+  contracts: type({
+    "[string]": type({
+      path: type("string").describe("Contract path")
+    })
+  }).optional()
 });
 async function getClarinetConfig(path) {
   const file = await readFile(path, "utf-8");
-  const config = ClarinetConfigSchema.parse(parse(file));
+  const config = ClarinetConfig.assert(parse(file));
   return config;
 }
 
@@ -78,23 +86,23 @@ import { dirname as dirname2, join, relative as relative2, resolve as resolve2 }
 import { stringify, parse as parse2 } from "@iarna/toml";
 import { readFile as readFile2 } from "fs/promises";
 var CONFIG_FILE = "Clarigen.toml";
-var typesSchema = z2.object({
-  output: z2.string().optional(),
-  outputs: z2.array(z2.string()).optional(),
-  include_accounts: z2.boolean().optional(),
-  after: z2.string().optional(),
-  include_boot_contracts: z2.boolean().optional(),
-  watch_folders: z2.array(z2.string()).optional()
+var typesSchema = type2({
+  "output?": type2("string").describe("Path to the output file"),
+  "outputs?": type2("string[]").describe("Paths to the output files"),
+  "include_accounts?": type2("boolean").describe("Include accounts in the output"),
+  "after?": type2("string").describe("Script to run after the output is generated"),
+  "include_boot_contracts?": type2("boolean").describe("Include boot contracts in the output"),
+  "watch_folders?": type2("string[]").describe("Folders to watch for changes")
 }).optional();
-var ConfigFileSchema = z2.object({
-  clarinet: z2.string(),
+var ConfigFile = type2({
+  clarinet: type2("string").describe("Path to the Clarinet config file"),
   ["types" /* ESM */]: typesSchema,
   ["esm" /* ESM_OLD */]: typesSchema,
-  ["docs" /* Docs */]: z2.object({
-    output: z2.string().optional(),
-    outputs: z2.array(z2.string()).optional(),
-    exclude: z2.array(z2.string()).optional(),
-    after: z2.string().optional()
+  ["docs" /* Docs */]: type2({
+    "output?": type2("string").describe("Path to docs output folder. Defaults to ./docs"),
+    "outputs?": type2("string[]").describe("Paths to docs output folders"),
+    "exclude?": type2("string[]").describe("Contracts to exclude from docs generation"),
+    "after?": type2("string").describe("Script to run after docs are generated")
   }).optional()
 });
 var defaultConfigFile = {
@@ -118,36 +126,36 @@ var Config = class {
     const clarinet = await getClarinetConfig(resolve2(cwd ?? "", config.clarinet));
     return new this(config, clarinet, cwd);
   }
-  getOutputs(type) {
+  getOutputs(type4) {
     var _a, _b;
-    const singlePath = (_a = this.configFile[type]) == null ? void 0 : _a.output;
-    const multiPath = ((_b = this.configFile[type]) == null ? void 0 : _b.outputs) || [];
+    const singlePath = (_a = this.configFile[type4]) == null ? void 0 : _a.output;
+    const multiPath = ((_b = this.configFile[type4]) == null ? void 0 : _b.outputs) || [];
     if (singlePath !== void 0) return [singlePath];
     return multiPath;
   }
-  outputResolve(type, filePath) {
-    const outputs = this.getOutputs(type);
-    if (!this.supports(type)) return null;
+  outputResolve(type4, filePath) {
+    const outputs = this.getOutputs(type4);
+    if (!this.supports(type4)) return null;
     return outputs.map((path) => {
       return resolve2(this.cwd, path, filePath || "");
     });
   }
-  async writeOutput(type, contents, filePath) {
-    const paths = this.outputResolve(type, filePath);
+  async writeOutput(type4, contents, filePath) {
+    const paths = this.outputResolve(type4, filePath);
     if (paths === null) return null;
     await Promise.all(
       paths.map(async (path) => {
         await writeFile(path, contents);
-        log.debug(`Generated ${type} file at ${relative2(this.cwd, path)}`);
+        log.debug(`Generated ${type4} file at ${relative2(this.cwd, path)}`);
       })
     );
     return paths;
   }
-  supports(type) {
-    return this.getOutputs(type).length > 0;
+  supports(type4) {
+    return this.getOutputs(type4).length > 0;
   }
-  type(type) {
-    return this.configFile[type];
+  type(type4) {
+    return this.configFile[type4];
   }
   get esm() {
     return this.configFile["types" /* ESM */];
@@ -173,16 +181,12 @@ async function getConfig(cwd) {
   if (await fileExists(path)) {
     const toml = await readFile2(path, "utf-8");
     const parsedToml = parse2(toml);
-    const parseResult = ConfigFileSchema.safeParse(parsedToml);
-    if (parseResult.success) {
-      sessionConfig = parseResult.data;
-    } else {
-      logger.error("Error parsing Clarigen.toml:");
-      parseResult.error.errors.forEach((e) => {
-        logger.error(`${e.path.join(".")}: ${e.message}`);
-      });
-      throw new Error("Error parsing Clarigen.toml");
+    const parsed = ConfigFile(parsedToml);
+    if (parsed instanceof type2.errors) {
+      logger.error(`Error parsing Clarigen config: ${parsed.summary}`);
+      throw new Error(`Error parsing Clarigen config: ${parsed.summary}`);
     }
+    sessionConfig = parsed;
   } else {
     sessionConfig = defaultConfigFile;
   }
@@ -191,7 +195,7 @@ async function getConfig(cwd) {
 
 // src/commands/base-command.ts
 import { Command, Option } from "clipanion";
-import { ZodError } from "zod";
+import { type as type3 } from "arktype";
 var BaseCommand = class extends Command {
   verbose = Option.Boolean("-v,--verbose", false, {
     description: "Enable verbose logging"
@@ -203,8 +207,8 @@ var BaseCommand = class extends Command {
   }
   // eslint-disable-next-line @typescript-eslint/require-await
   async catch(error) {
-    if (error instanceof ZodError) {
-      logger.error(error.issues, "Your configuration file is invalid.");
+    if (error instanceof type3.errors) {
+      logger.error("Your configuration file is invalid.", error.summary);
       return;
     }
     logger.error(error);
@@ -291,9 +295,9 @@ var jsTypeFromAbiType = (val, isArgument = false) => {
     return `${innerType} | null`;
   } else if (isClarityAbiTuple(val)) {
     const tupleDefs = [];
-    val.tuple.forEach(({ name, type }) => {
+    val.tuple.forEach(({ name, type: type4 }) => {
       const camelName = toCamelCase2(name);
-      const innerType = jsTypeFromAbiType(type, isArgument);
+      const innerType = jsTypeFromAbiType(type4, isArgument);
       tupleDefs.push(`"${camelName}": ${innerType};`);
     });
     return `{
@@ -493,9 +497,9 @@ export const simnet = {
 function encodeVariables(variables) {
   return variables.map((v) => {
     let varLine = `${encodeVariableName(v.name)}: `;
-    const type = jsTypeFromAbiType(v.type);
+    const type4 = jsTypeFromAbiType(v.type);
     const varJSON = serialize(v);
-    varLine += `${varJSON} as TypedAbiVariable<${type}>`;
+    varLine += `${varJSON} as TypedAbiVariable<${type4}>`;
     return varLine;
   });
 }
@@ -532,6 +536,20 @@ function serializeArray(key, lines) {
 }
 
 // src/files/variables.ts
+function clarityVersionForContract(contract) {
+  switch (contract.contract_interface.clarity_version) {
+    case "Clarity1":
+      return 1;
+    case "Clarity2":
+      return 2;
+    case "Clarity3":
+      return 3;
+    case "Clarity4":
+      return 4;
+    default:
+      return 3;
+  }
+}
 function getVariablesV2(contract, simnet, verbose) {
   const [deployer] = contract.contract_id.split(".");
   const fakeId = `${getContractName3(contract.contract_id)}-vars`;
@@ -567,7 +585,7 @@ ${varFn}`;
       fakeId,
       fullSrc,
       {
-        clarityVersion: 3
+        clarityVersion: clarityVersionForContract(contract)
       },
       deployer
     );
@@ -633,7 +651,11 @@ async function getSession(config) {
       }
       return {
         contract_id,
-        contract_interface,
+        contract_interface: {
+          ...contract_interface,
+          epoch: contract_interface.epoch,
+          clarity_version: contract_interface.clarity_version
+        },
         source: source ?? ""
       };
     })
@@ -866,7 +888,7 @@ async function afterESM(config) {
 
 // src/commands/default-command.ts
 import chokidar from "chokidar";
-import { dirname as dirname4, join as join3, relative as relative4 } from "path";
+import { dirname as dirname4, join as join3, relative as relative4 } from "node:path";
 async function generate(config) {
   const session = await getSession(config);
   const baseFile = generateBaseFile(session);
@@ -1039,8 +1061,8 @@ function clarityNameMatcher(line) {
   return /[\w|\-|\?|\!]+/.exec(line);
 }
 function findItemNameFromLine(line) {
-  const fnType = FN_TYPES.find((type) => {
-    return line.startsWith(`(define-${type}`);
+  const fnType = FN_TYPES.find((type4) => {
+    return line.startsWith(`(define-${type4}`);
   });
   if (fnType) {
     const prefix = `(define-${fnType} (`;
@@ -1053,13 +1075,13 @@ function findItemNameFromLine(line) {
     }
     return match[0];
   }
-  for (const type of VAR_TYPES) {
-    const prefix = `(define-${type} `;
+  for (const type4 of VAR_TYPES) {
+    const prefix = `(define-${type4} `;
     if (!line.startsWith(prefix)) continue;
     const startString = line.slice(prefix.length);
     const match = clarityNameMatcher(startString);
     if (!match) {
-      console.debug(`[claridocs]: Unable to determine ${type} name from line:
+      console.debug(`[claridocs]: Unable to determine ${type4} name from line:
   \`${line}\``);
       return;
     }
@@ -1331,8 +1353,8 @@ function generateReadme(session, excluded) {
     contractLines.push(line);
   });
   const fileContents = `# Contracts
-  
-  ${contractLines.join("\n")}
+
+${contractLines.join("\n")}
   `;
   return fileContents;
 }
@@ -1396,23 +1418,81 @@ output = "docs/"
 }
 
 // src/commands/docs-command.ts
+import { dirname as dirname5, join as join4, relative as relative6 } from "node:path";
+import chokidar2 from "chokidar";
+async function watch2(config, cwd) {
+  return new Promise(async (resolve3, reject) => {
+    var _a;
+    const session = await getSession(config);
+    try {
+      await generateDocs({
+        session,
+        config
+      });
+    } catch (error) {
+      logger.error({ error }, "Error generating types");
+    }
+    const clarinetFolder = dirname5(config.clarinetFile());
+    const contractsFolder = join4(clarinetFolder, "/contracts/**/*.clar");
+    const relativeFolder = relative6(cwd || process.cwd(), contractsFolder);
+    const watchFolders = ((_a = config.esm) == null ? void 0 : _a.watch_folders) ?? [];
+    watchFolders.push(relativeFolder);
+    logger.info(`Watching for changes in ${watchFolders}`);
+    const watcher = chokidar2.watch(watchFolders, { persistent: true, cwd: clarinetFolder });
+    let running = false;
+    let start = 0;
+    const isVerbose = logger.level !== "info";
+    watcher.on("change", async (path) => {
+      if (!running) {
+        start = Date.now();
+        logger.info(`File ${path} has been changed. Generating types.`);
+        running = true;
+        const session2 = await getSession(config);
+        void generateDocs({
+          session: session2,
+          config
+        }).catch((e) => {
+          logger.error({ error: e }, "Error generating types");
+        }).then(() => {
+          setTimeout(() => {
+            process.stdout.moveCursor(0, -1);
+            process.stdout.clearLine(1);
+            const elapsed = Date.now() - start;
+            logger.info(
+              `Docs generated (${(elapsed / 1e3).toFixed(2)}s). Watching for changes...`
+            );
+            running = false;
+          });
+        });
+      }
+    });
+  });
+}
 var DocsCommand = class extends BaseCommand {
   static paths = [["docs"]];
   static usage = BaseCommand.Usage({
     description: "Generate markdown documentation for your Clarity contracts"
   });
   cwd = Option4.String({ required: false });
+  watch = Option4.Boolean("-w,--watch", {
+    description: "Watch for changes and regenerate docs",
+    required: false
+  });
   async execute() {
     this.preexecute();
     const config = await Config.load(this.cwd);
-    const session = await getSession(config);
-    await generateDocs({
-      session: {
-        ...session,
-        variables: []
-      },
-      config
-    });
+    if (this.watch) {
+      await watch2(config, this.cwd);
+    } else {
+      const session = await getSession(config);
+      await generateDocs({
+        session: {
+          ...session,
+          variables: []
+        },
+        config
+      });
+    }
   }
 };
 
@@ -1477,7 +1557,7 @@ var InitConfigCommand = class extends BaseCommand {
 };
 
 // src/generated/version.ts
-var version = "3.1.0";
+var version = "3.2.0";
 
 // src/run-cli.ts
 var [node, script, ...args] = process.argv;