@secondlayer/cli 14.3.0 → 15.0.0

package/dist/index.js

@@ -46,13 +46,8 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-// src/types/plugin.ts
-function isClarinetContract(c) {
-  return "_clarinetSource" in c && c._clarinetSource === true;
-}
-function isDirectFileContract(c) {
-  return "_directFile" in c && c._directFile === true;
-}
+// src/utils/constants.ts
+var DEFAULT_SENDER_ADDRESS = "SP000000000000000000002Q6VF78";
 
 // src/utils/contract-id.ts
 function parseContractId(contractId) {
@@ -66,339 +61,137 @@ function parseContractId(contractId) {
   };
 }
 
-// src/utils/format.ts
-var exports_format = {};
-__export(exports_format, {
-  formatCode: () => formatCode
-});
-import { Biome, Distribution } from "@biomejs/js-api";
-async function getBiome() {
-  if (!biome) {
-    biome = await Biome.create({
-      distribution: Distribution.NODE
-    });
-    biome.applyConfiguration({
-      formatter: {
-        enabled: true,
-        indentStyle: "tab",
-        lineWidth: 80
-      },
-      javascript: {
-        formatter: {
-          semicolons: "always",
-          quoteStyle: "single"
-        }
-      },
-      organizeImports: {
-        enabled: true
-      },
-      linter: {
-        enabled: true
-      },
-      assists: {
-        enabled: true
-      }
-    });
-  }
-  return biome;
-}
-async function formatCode(code) {
-  const b = await getBiome();
-  const linted = b.lintContent(code, {
-    filePath: "generated.ts",
-    fixFileMode: "SafeFixes"
-  });
-  const formatted = b.formatContent(linted.content, {
-    filePath: "generated.ts"
-  });
-  return formatted.content;
-}
-var biome = null;
-var init_format = () => {};
-
-// src/core/plugin-manager.ts
-import { promises as fs } from "node:fs";
-import path from "node:path";
-import { isValidAddress as _validateStacksAddress } from "@secondlayer/stacks";
-import { getErrorMessage } from "@secondlayer/shared";
+// src/plugins/clarinet/index.ts
 import { toCamelCase } from "@secondlayer/stacks/clarity";
-
-class PluginManager {
-  plugins = [];
-  logger;
-  utils;
-  executionContext;
-  constructor() {
-    this.logger = this.createLogger();
-    this.utils = this.createUtils();
-    this.executionContext = {
-      phase: "config",
-      startTime: Date.now(),
-      results: new Map
-    };
+import { normalizeAbi } from "@secondlayer/stacks/clarity";
+import { initSimnet } from "@stacks/clarinet-sdk";
+function sanitizeContractName(name) {
+  return toCamelCase(name);
+}
+function matchesContractFilters(name, options) {
+  if (options.include && !options.include.includes(name)) {
+    return false;
   }
-  register(plugin) {
-    if (!plugin.name || !plugin.version) {
-      throw new Error("Plugin must have a name and version");
+  if (options.exclude?.includes(name)) {
+    return false;
+  }
+  return true;
+}
+async function readManifestInfo(manifestPath) {
+  try {
+    const { promises: fs } = await import("node:fs");
+    const tomlContent = await fs.readFile(manifestPath, "utf-8");
+    const projectContracts = new Set;
+    const contractSectionRegex = /^\[contracts\.([^\]]+)\]/gm;
+    let match = contractSectionRegex.exec(tomlContent);
+    while (match !== null) {
+      projectContracts.add(match[1]);
+      match = contractSectionRegex.exec(tomlContent);
     }
-    const existing = this.plugins.find((p) => p.name === plugin.name);
-    if (existing) {
-      throw new Error(`Plugin "${plugin.name}" is already registered (version ${existing.version})`);
+    const requirementIds = new Set;
+    const requirementRegex = /contract_id\s*=\s*["']([^"']+)["']/g;
+    match = requirementRegex.exec(tomlContent);
+    while (match !== null) {
+      requirementIds.add(match[1]);
+      match = requirementRegex.exec(tomlContent);
     }
-    this.plugins.push(plugin);
-    this.logger.debug(`Registered plugin: ${plugin.name}@${plugin.version}`);
+    return { projectContracts, requirementIds };
+  } catch {
+    return null;
   }
-  getPlugins() {
-    return [...this.plugins];
+}
+function classifyContract(contractId, manifest) {
+  const { address, contractName } = parseContractId(contractId);
+  if (manifest) {
+    if (manifest.projectContracts.has(contractName))
+      return "project";
+    if (manifest.requirementIds.has(contractId))
+      return "requirement";
+    return "system";
   }
-  async transformConfig(config) {
-    this.executionContext.phase = "config";
-    let transformedConfig = { ...config };
-    for (const plugin of this.plugins) {
-      if (plugin.transformConfig) {
-        this.executionContext.currentPlugin = plugin;
-        try {
-          const result = await plugin.transformConfig(transformedConfig);
-          transformedConfig = result;
-          this.recordHookResult(plugin.name, "transformConfig", {
-            success: true
-          });
-        } catch (error) {
-          this.recordHookResult(plugin.name, "transformConfig", {
-            success: false,
-            error: error instanceof Error ? error : new Error(getErrorMessage(error))
-          });
-          throw new Error(`Plugin "${plugin.name}" failed during config transformation: ${getErrorMessage(error)}`);
-        }
-      }
-    }
-    const resolvedConfig = {
-      ...transformedConfig,
-      plugins: this.plugins
-    };
-    return resolvedConfig;
+  const systemContractPatterns = [
+    /^pox-\d+$/,
+    /^bns$/,
+    /^costs-\d+$/,
+    /^lockup$/,
+    /^signer-manager$/
+  ];
+  if (systemContractPatterns.some((pattern) => pattern.test(contractName))) {
+    return "system";
   }
-  async transformContracts(contracts, _config) {
-    const processedContracts = [];
-    for (let contract of contracts) {
-      if (isClarinetContract(contract) && contract.abi) {
-        processedContracts.push(this.contractToProcessed(contract, "clarinet"));
-        continue;
-      }
-      if (isDirectFileContract(contract) && contract.abi) {
-        processedContracts.push(this.contractToProcessed(contract, "direct"));
-        continue;
-      }
-      for (const plugin of this.plugins) {
-        if (plugin.transformContract) {
-          this.executionContext.currentPlugin = plugin;
-          try {
-            contract = await plugin.transformContract(contract);
-            this.recordHookResult(plugin.name, "transformContract", {
-              success: true
-            });
-          } catch (error) {
-            this.recordHookResult(plugin.name, "transformContract", {
-              success: false,
-              error: error instanceof Error ? error : new Error(getErrorMessage(error))
-            });
-            this.logger.warn(`Plugin "${plugin.name}" failed to transform contract: ${getErrorMessage(error)}`);
-          }
-        }
-      }
-      if (contract.abi) {
-        processedContracts.push(this.contractToProcessed(contract, "api"));
-      }
-    }
-    return processedContracts;
+  const systemAddresses = [
+    DEFAULT_SENDER_ADDRESS,
+    "ST000000000000000000002AMW42H"
+  ];
+  if (systemAddresses.includes(address)) {
+    return "system";
   }
-  async executeHook(hookName, context) {
-    for (const plugin of this.plugins) {
-      const hook = plugin[hookName];
-      if (typeof hook === "function") {
-        this.executionContext.currentPlugin = plugin;
-        try {
-          await hook.call(plugin, context);
-          this.recordHookResult(plugin.name, hookName, {
-            success: true
-          });
-        } catch (error) {
-          this.recordHookResult(plugin.name, hookName, {
-            success: false,
-            error: error instanceof Error ? error : new Error(getErrorMessage(error))
-          });
-          this.logger.error(`Plugin "${plugin.name}" failed during ${hookName}: ${getErrorMessage(error)}`);
+  return "project";
+}
+async function loadClarinetContracts(options = {}) {
+  const manifestPath = options.path || "./Clarinet.toml";
+  try {
+    const simnet = await initSimnet(manifestPath);
+    const contractInterfaces = simnet.getContractsInterfaces();
+    const contracts = [];
+    const manifest = await readManifestInfo(manifestPath);
+    const includeRequirements = options.includeRequirements ?? true;
+    for (const [contractId, abi] of contractInterfaces) {
+      const { contractName } = parseContractId(contractId);
+      const kind = classifyContract(contractId, manifest);
+      if (kind === "system" || kind === "requirement" && !includeRequirements) {
+        if (options.debug) {
+          console.log(`\uD83D\uDEAB Skipping ${kind} contract: ${contractId}`);
         }
+        continue;
       }
-    }
-  }
-  async executeGeneration(contracts, config) {
-    this.executionContext.phase = "generate";
-    const outputs = new Map;
-    const context = {
-      config,
-      logger: this.logger,
-      utils: this.utils,
-      contracts,
-      outputs,
-      augment: (outputKey, contractName, content) => {
-        this.augmentOutput(outputs, outputKey, contractName, content);
-      },
-      addOutput: (key, output) => {
-        outputs.set(key, output);
-      }
-    };
-    await this.executeHook("beforeGenerate", context);
-    await this.executeHook("generate", context);
-    await this.executeHook("afterGenerate", context);
-    return outputs;
-  }
-  async transformOutputs(outputs) {
-    this.executionContext.phase = "output";
-    const transformedOutputs = new Map;
-    for (const [key, output] of outputs) {
-      let transformedContent = output.content;
-      for (const plugin of this.plugins) {
-        if (plugin.transformOutput) {
-          this.executionContext.currentPlugin = plugin;
-          try {
-            transformedContent = await plugin.transformOutput(transformedContent, output.type || "other");
-            this.recordHookResult(plugin.name, "transformOutput", {
-              success: true
-            });
-          } catch (error) {
-            this.recordHookResult(plugin.name, "transformOutput", {
-              success: false,
-              error: error instanceof Error ? error : new Error(getErrorMessage(error))
-            });
-            this.logger.warn(`Plugin "${plugin.name}" failed to transform output: ${getErrorMessage(error)}`);
-          }
-        }
+      if (!matchesContractFilters(contractName, options)) {
+        continue;
       }
-      transformedOutputs.set(key, {
-        ...output,
-        content: transformedContent
+      contracts.push({
+        name: sanitizeContractName(contractName),
+        address: contractId,
+        abi: normalizeAbi(abi),
+        _clarinetSource: true
       });
     }
-    return transformedOutputs;
-  }
-  async writeOutputs(outputs) {
-    for (const [, output] of outputs) {
-      try {
-        const resolvedPath = path.resolve(process.cwd(), output.path);
-        await this.utils.ensureDir(path.dirname(resolvedPath));
-        await this.utils.writeFile(resolvedPath, output.content);
-      } catch (error) {
-        this.logger.error(`Failed to write ${output.path}: ${getErrorMessage(error)}`);
-        throw error;
-      }
+    if (options.debug) {
+      console.log(`\uD83D\uDD0D Clarinet found ${contracts.length} user-defined contracts`);
     }
-  }
-  getExecutionResults() {
-    return new Map(this.executionContext.results);
-  }
-  contractToProcessed(contract, source) {
-    const address = typeof contract.address === "string" ? contract.address : "";
-    const parsed = parseContractId(address);
-    return {
-      name: contract.name || parsed.contractName || "unknown",
-      address: parsed.address || "unknown",
-      contractName: parsed.contractName || contract.name || "unknown",
-      abi: contract.abi,
-      source: source === "api" ? "api" : "local",
-      metadata: contract.metadata ?? { source }
-    };
-  }
-  augmentOutput(outputs, outputKey, contractName, content) {
-    const existing = outputs.get(outputKey);
-    if (!existing) {
-      this.logger.warn(`Cannot augment non-existent output: ${outputKey}`);
-      return;
+    return contracts;
+  } catch (error) {
+    const err = error;
+    if (await hasClarinetProject(manifestPath)) {
+      console.warn(`⚠️  Clarinet: found ${manifestPath} but failed to load contracts: ${err.message}`);
+    } else if (options.debug) {
+      console.warn(`⚠️  Clarinet: no manifest at ${manifestPath}, skipping`);
     }
-    const augmentedContent = `${existing.content}
-
-// Augmented by plugin for ${contractName}
-${JSON.stringify(content, null, 2)}`;
-    outputs.set(outputKey, {
-      ...existing,
-      content: augmentedContent
-    });
-  }
-  recordHookResult(pluginName, hookName, result) {
-    const key = `${pluginName}:${hookName}`;
-    const existing = this.executionContext.results.get(key) || [];
-    existing.push({ ...result, plugin: pluginName });
-    this.executionContext.results.set(key, existing);
-  }
-  createLogger() {
-    return {
-      info: (message) => console.log(`ℹ️  ${message}`),
-      warn: (message) => console.warn(`⚠️  ${message}`),
-      error: (message) => console.error(`❌ ${message}`),
-      debug: (message) => {
-        if (process.env.DEBUG) {
-          console.log(`\uD83D\uDC1B ${message}`);
-        }
-      },
-      success: (message) => console.log(`✅ ${message}`)
-    };
+    return [];
   }
-  createUtils() {
-    return {
-      toCamelCase,
-      toKebabCase: (str) => {
-        return str.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
-      },
-      validateAddress: (address) => {
-        return validateStacksAddress(parseContractId(address).address);
-      },
-      parseContractId: (contractId) => {
-        return parseContractId(contractId);
-      },
-      formatCode: async (code) => {
-        const { formatCode: formatCode2 } = await Promise.resolve().then(() => (init_format(), exports_format));
-        return formatCode2(code);
-      },
-      resolvePath: (relativePath) => {
-        return path.resolve(process.cwd(), relativePath);
-      },
-      fileExists: async (filePath) => {
-        try {
-          await fs.access(filePath);
-          return true;
-        } catch {
-          return false;
-        }
-      },
-      readFile: async (filePath) => {
-        return fs.readFile(filePath, "utf-8");
-      },
-      writeFile: async (filePath, content) => {
-        await fs.writeFile(filePath, content, "utf-8");
-      },
-      ensureDir: async (dirPath) => {
-        await fs.mkdir(dirPath, { recursive: true });
-      }
-    };
+}
+async function hasClarinetProject(path = "./Clarinet.toml") {
+  try {
+    const { promises: fs } = await import("node:fs");
+    await fs.access(path);
+    return true;
+  } catch {
+    return false;
   }
 }
-var validateStacksAddress;
-var init_plugin_manager = __esm(() => {
-  validateStacksAddress = _validateStacksAddress;
-});
+var init_clarinet = () => {};
 
 // src/utils/config.ts
 import { randomBytes } from "node:crypto";
-import { promises as fs2 } from "node:fs";
+import { promises as fs } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
 import { tmpdir } from "node:os";
-import path2 from "node:path";
+import path from "node:path";
 import { pathToFileURL } from "node:url";
 async function findConfigFile(cwd) {
   for (const fileName of CONFIG_FILE_NAMES) {
-    const filePath = path2.join(cwd, fileName);
+    const filePath = path.join(cwd, fileName);
     try {
-      await fs2.access(filePath);
+      await fs.access(filePath);
       return filePath;
     } catch {}
   }
@@ -406,21 +199,21 @@ async function findConfigFile(cwd) {
 }
 async function loadConfig(configPath) {
   const cwd = process.cwd();
-  const resolvedPath = configPath ? path2.resolve(cwd, configPath) : await findConfigFile(cwd);
+  const resolvedPath = configPath ? path.resolve(cwd, configPath) : await findConfigFile(cwd);
   if (!resolvedPath) {
     throw new Error("No config file found. Create a secondlayer.config.ts file or specify a path with --config");
   }
   let config;
   if (resolvedPath.endsWith(".ts")) {
-    const code = await fs2.readFile(resolvedPath, "utf-8");
+    const code = await fs.readFile(resolvedPath, "utf-8");
     let replacementPath;
     try {
       const require2 = createRequire2(import.meta.url);
       const packagePath = require2.resolve("@secondlayer/cli");
       replacementPath = pathToFileURL(packagePath).href;
     } catch {
-      const currentModuleDir = path2.dirname(new URL(import.meta.url).pathname);
-      const indexPath = path2.resolve(currentModuleDir, "../index");
+      const currentModuleDir = path.dirname(new URL(import.meta.url).pathname);
+      const indexPath = path.resolve(currentModuleDir, "../index");
       replacementPath = pathToFileURL(indexPath).href;
     }
     const transformedCode = code.replace(/from\s+["']@secondlayer\/cli["']/g, `from '${replacementPath}'`);
@@ -430,14 +223,14 @@ async function loadConfig(configPath) {
       target: "node18",
       loader: "ts"
     });
-    const tempPath = path2.join(tmpdir(), `secondlayer-config-${randomBytes(4).toString("hex")}.mjs`);
-    await fs2.writeFile(tempPath, result.code);
+    const tempPath = path.join(tmpdir(), `secondlayer-config-${randomBytes(4).toString("hex")}.mjs`);
+    await fs.writeFile(tempPath, result.code);
     try {
       const fileUrl = pathToFileURL(tempPath).href;
       const module = await import(fileUrl);
       config = module.default;
     } finally {
-      await fs2.unlink(tempPath).catch(() => {});
+      await fs.unlink(tempPath).catch(() => {});
     }
   } else {
     const fileUrl = pathToFileURL(resolvedPath).href;
@@ -451,14 +244,15 @@ async function loadConfig(configPath) {
     config = config({});
   }
   validateConfig(config);
-  const pluginManager = new PluginManager;
-  if (config.plugins && Array.isArray(config.plugins)) {
-    for (const plugin of config.plugins) {
-      pluginManager.register(plugin);
-    }
+  if (config.clarinet === true || config.clarinet && typeof config.clarinet === "object") {
+    const options = config.clarinet === true ? {} : config.clarinet;
+    const loaded = await loadClarinetContracts(options);
+    config = {
+      ...config,
+      contracts: [...config.contracts || [], ...loaded]
+    };
   }
-  const resolvedConfig = await pluginManager.transformConfig(config);
-  return resolvedConfig;
+  return config;
 }
 function validateConfig(config) {
   if (!config || typeof config !== "object") {
@@ -473,13 +267,13 @@ function validateConfig(config) {
   }
   if (c.contracts) {
     for (const contract of c.contracts) {
-      if (!contract.address && !contract.source) {
+      if (!contract.address && !contract.source && !contract.abi) {
         throw new Error("Each contract must have either an address or source");
       }
     }
   }
-  if (c.plugins && !Array.isArray(c.plugins)) {
-    throw new Error("Config plugins must be an array");
+  if (c.clarinet !== undefined && typeof c.clarinet !== "boolean" && (typeof c.clarinet !== "object" || c.clarinet === null)) {
+    throw new Error("Config clarinet must be true or an options object");
   }
 }
 function defineConfig(configOrDefiner) {
@@ -487,7 +281,7 @@ function defineConfig(configOrDefiner) {
 }
 var CONFIG_FILE_NAMES;
 var init_config = __esm(() => {
-  init_plugin_manager();
+  init_clarinet();
   CONFIG_FILE_NAMES = [
     "secondlayer.config.ts",
     "secondlayer.config",
@@ -497,11 +291,9 @@ var init_config = __esm(() => {
 
 // src/index.ts
 init_config();
-init_plugin_manager();
 export {
-  defineConfig,
-  PluginManager
+  defineConfig
 };
 
-//# debugId=30EC1633862357D564756E2164756E21
+//# debugId=0B67AD9AFC5A2DC564756E2164756E21
 //# sourceMappingURL=index.js.map