@clarigen/cli 3.1.0 → 3.2.0

package/dist/run-cli.cjs

@@ -30,7 +30,7 @@ var import_clipanion6 = require("clipanion");
 var import_clipanion2 = require("clipanion");
 
 // src/config.ts
-var import_zod2 = require("zod");
+var import_arktype2 = require("arktype");
 
 // src/logger.ts
 var import_pino = require("pino");
@@ -80,19 +80,27 @@ function sortContracts(contracts) {
 }
 
 // src/clarinet-config.ts
-var import_zod = require("zod");
+var import_arktype = require("arktype");
 var import_promises2 = require("fs/promises");
 var import_toml = require("@iarna/toml");
-var ClarinetConfigSchema = import_zod.z.object({
-  project: import_zod.z.object({
-    requirements: import_zod.z.array(import_zod.z.object({ contract_id: import_zod.z.string() })).optional(),
-    cache_location: import_zod.z.object({ path: import_zod.z.string() }).optional()
+var ClarinetConfig = (0, import_arktype.type)({
+  project: (0, import_arktype.type)({
+    requirements: (0, import_arktype.type)({
+      contract_id: (0, import_arktype.type)("string").describe("Contract ID")
+    }).array().describe("Project requirements").optional(),
+    cache_location: (0, import_arktype.type)({
+      path: (0, import_arktype.type)("string").describe("Cache location path")
+    }).optional()
   }),
-  contracts: import_zod.z.record(import_zod.z.string(), import_zod.z.object({ path: import_zod.z.string() })).optional()
+  contracts: (0, import_arktype.type)({
+    "[string]": (0, import_arktype.type)({
+      path: (0, import_arktype.type)("string").describe("Contract path")
+    })
+  }).optional()
 });
 async function getClarinetConfig(path) {
   const file = await (0, import_promises2.readFile)(path, "utf-8");
-  const config = ClarinetConfigSchema.parse((0, import_toml.parse)(file));
+  const config = ClarinetConfig.assert((0, import_toml.parse)(file));
   return config;
 }
 
@@ -101,23 +109,23 @@ var import_path2 = require("path");
 var import_toml2 = require("@iarna/toml");
 var import_promises3 = require("fs/promises");
 var CONFIG_FILE = "Clarigen.toml";
-var typesSchema = import_zod2.z.object({
-  output: import_zod2.z.string().optional(),
-  outputs: import_zod2.z.array(import_zod2.z.string()).optional(),
-  include_accounts: import_zod2.z.boolean().optional(),
-  after: import_zod2.z.string().optional(),
-  include_boot_contracts: import_zod2.z.boolean().optional(),
-  watch_folders: import_zod2.z.array(import_zod2.z.string()).optional()
+var typesSchema = (0, import_arktype2.type)({
+  "output?": (0, import_arktype2.type)("string").describe("Path to the output file"),
+  "outputs?": (0, import_arktype2.type)("string[]").describe("Paths to the output files"),
+  "include_accounts?": (0, import_arktype2.type)("boolean").describe("Include accounts in the output"),
+  "after?": (0, import_arktype2.type)("string").describe("Script to run after the output is generated"),
+  "include_boot_contracts?": (0, import_arktype2.type)("boolean").describe("Include boot contracts in the output"),
+  "watch_folders?": (0, import_arktype2.type)("string[]").describe("Folders to watch for changes")
 }).optional();
-var ConfigFileSchema = import_zod2.z.object({
-  clarinet: import_zod2.z.string(),
+var ConfigFile = (0, import_arktype2.type)({
+  clarinet: (0, import_arktype2.type)("string").describe("Path to the Clarinet config file"),
   ["types" /* ESM */]: typesSchema,
   ["esm" /* ESM_OLD */]: typesSchema,
-  ["docs" /* Docs */]: import_zod2.z.object({
-    output: import_zod2.z.string().optional(),
-    outputs: import_zod2.z.array(import_zod2.z.string()).optional(),
-    exclude: import_zod2.z.array(import_zod2.z.string()).optional(),
-    after: import_zod2.z.string().optional()
+  ["docs" /* Docs */]: (0, import_arktype2.type)({
+    "output?": (0, import_arktype2.type)("string").describe("Path to docs output folder. Defaults to ./docs"),
+    "outputs?": (0, import_arktype2.type)("string[]").describe("Paths to docs output folders"),
+    "exclude?": (0, import_arktype2.type)("string[]").describe("Contracts to exclude from docs generation"),
+    "after?": (0, import_arktype2.type)("string").describe("Script to run after docs are generated")
   }).optional()
 });
 var defaultConfigFile = {
@@ -141,36 +149,36 @@ var Config = class {
     const clarinet = await getClarinetConfig((0, import_path2.resolve)(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 (0, import_path2.resolve)(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 ${(0, import_path2.relative)(this.cwd, path)}`);
+        log.debug(`Generated ${type4} file at ${(0, import_path2.relative)(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 */];
@@ -196,16 +204,12 @@ async function getConfig(cwd) {
   if (await fileExists(path)) {
     const toml = await (0, import_promises3.readFile)(path, "utf-8");
     const parsedToml = (0, import_toml2.parse)(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 import_arktype2.type.errors) {
+      logger.error(`Error parsing Clarigen config: ${parsed.summary}`);
+      throw new Error(`Error parsing Clarigen config: ${parsed.summary}`);
     }
+    sessionConfig = parsed;
   } else {
     sessionConfig = defaultConfigFile;
   }
@@ -214,7 +218,7 @@ async function getConfig(cwd) {
 
 // src/commands/base-command.ts
 var import_clipanion = require("clipanion");
-var import_zod3 = require("zod");
+var import_arktype3 = require("arktype");
 var BaseCommand = class extends import_clipanion.Command {
   verbose = import_clipanion.Option.Boolean("-v,--verbose", false, {
     description: "Enable verbose logging"
@@ -226,8 +230,8 @@ var BaseCommand = class extends import_clipanion.Command {
   }
   // eslint-disable-next-line @typescript-eslint/require-await
   async catch(error) {
-    if (error instanceof import_zod3.ZodError) {
-      logger.error(error.issues, "Your configuration file is invalid.");
+    if (error instanceof import_arktype3.type.errors) {
+      logger.error("Your configuration file is invalid.", error.summary);
       return;
     }
     logger.error(error);
@@ -296,9 +300,9 @@ var jsTypeFromAbiType = (val, isArgument = false) => {
     return `${innerType} | null`;
   } else if ((0, import_core2.isClarityAbiTuple)(val)) {
     const tupleDefs = [];
-    val.tuple.forEach(({ name, type }) => {
+    val.tuple.forEach(({ name, type: type4 }) => {
       const camelName = (0, import_core3.toCamelCase)(name);
-      const innerType = jsTypeFromAbiType(type, isArgument);
+      const innerType = jsTypeFromAbiType(type4, isArgument);
       tupleDefs.push(`"${camelName}": ${innerType};`);
     });
     return `{
@@ -498,9 +502,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;
   });
 }
@@ -537,6 +541,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 = `${(0, import_core6.getContractName)(contract.contract_id)}-vars`;
@@ -572,7 +590,7 @@ ${varFn}`;
       fakeId,
       fullSrc,
       {
-        clarityVersion: 3
+        clarityVersion: clarityVersionForContract(contract)
       },
       deployer
     );
@@ -638,7 +656,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 ?? ""
       };
     })
@@ -871,7 +893,7 @@ async function afterESM(config) {
 
 // src/commands/default-command.ts
 var import_chokidar = __toESM(require("chokidar"), 1);
-var import_path4 = require("path");
+var import_node_path = require("path");
 async function generate(config) {
   const session = await getSession(config);
   const baseFile = generateBaseFile(session);
@@ -897,9 +919,9 @@ async function watch(config, cwd) {
     } catch (error) {
       logger.error({ error }, "Error generating types");
     }
-    const clarinetFolder = (0, import_path4.dirname)(config.clarinetFile());
-    const contractsFolder = (0, import_path4.join)(clarinetFolder, "/contracts/**/*.clar");
-    const relativeFolder = (0, import_path4.relative)(cwd || process.cwd(), contractsFolder);
+    const clarinetFolder = (0, import_node_path.dirname)(config.clarinetFile());
+    const contractsFolder = (0, import_node_path.join)(clarinetFolder, "/contracts/**/*.clar");
+    const relativeFolder = (0, import_node_path.relative)(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}`);
@@ -963,7 +985,7 @@ var import_clipanion4 = require("clipanion");
 
 // src/files/docs.ts
 var import_core10 = require("@clarigen/core");
-var import_path6 = require("path");
+var import_path5 = require("path");
 
 // src/docs/markdown.ts
 var import_core9 = require("@clarigen/core");
@@ -1044,8 +1066,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} (`;
@@ -1058,13 +1080,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;
     }
@@ -1159,7 +1181,7 @@ async function afterDocs(config) {
 }
 
 // src/docs/markdown.ts
-var import_path5 = require("path");
+var import_path4 = require("path");
 function generateMarkdown({
   contract,
   contractFile,
@@ -1176,7 +1198,7 @@ function generateMarkdown({
   const constants = doc.variables.filter((v) => v.abi.access === "constant").map((v) => markdownVar(v, contractFile));
   let fileLine = "";
   if (contractFile) {
-    const fileName = (0, import_path5.basename)(contractFile);
+    const fileName = (0, import_path4.basename)(contractFile);
     fileLine = `
 [\`${fileName}\`](${contractFile})`;
   }
@@ -1336,8 +1358,8 @@ function generateReadme(session, excluded) {
     contractLines.push(line);
   });
   const fileContents = `# Contracts
-  
-  ${contractLines.join("\n")}
+
+${contractLines.join("\n")}
   `;
   return fileContents;
 }
@@ -1353,7 +1375,7 @@ async function generateDocs({
     warnNoDocs();
     return;
   }
-  const docsPathExt = (0, import_path6.extname)(docsBase);
+  const docsPathExt = (0, import_path5.extname)(docsBase);
   if (docsPathExt) {
     log.warn(`Docs output path ('${docsBase}') looks like a file - it needs to be a directory.`);
   }
@@ -1374,7 +1396,7 @@ async function generateDocs({
       let contractFile;
       if (contractPathDef) {
         const contractPathFull = config.joinFromClarinet(contractPathDef);
-        contractFile = (0, import_path6.relative)(docsBaseFolder, contractPathFull);
+        contractFile = (0, import_path5.relative)(docsBaseFolder, contractPathFull);
       } else {
         log.debug(`Couldn't find contract file from Clarinet.toml for contract ${name}`);
       }
@@ -1401,23 +1423,81 @@ output = "docs/"
 }
 
 // src/commands/docs-command.ts
+var import_node_path2 = require("path");
+var import_chokidar2 = __toESM(require("chokidar"), 1);
+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 = (0, import_node_path2.dirname)(config.clarinetFile());
+    const contractsFolder = (0, import_node_path2.join)(clarinetFolder, "/contracts/**/*.clar");
+    const relativeFolder = (0, import_node_path2.relative)(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 = import_chokidar2.default.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 = import_clipanion4.Option.String({ required: false });
+  watch = import_clipanion4.Option.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
+      });
+    }
   }
 };
 
@@ -1482,7 +1562,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;