@secondlayer/cli 0.1.0 → 0.2.0

package/dist/cli.js

@@ -1,45 +1,38 @@
 #!/usr/bin/env node
+// @bun
 var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
 var __export = (target, all) => {
   for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
 };
-
-// node_modules/tsup/assets/esm_shims.js
-import path from "path";
-import { fileURLToPath } from "url";
-var init_esm_shims = __esm({
-  "node_modules/tsup/assets/esm_shims.js"() {
-    "use strict";
-  }
-});
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
 // src/commands/init.ts
-var init_exports = {};
-__export(init_exports, {
+var exports_init = {};
+__export(exports_init, {
   init: () => init
 });
-import { promises as fs3 } from "fs";
+import { promises as fs4 } from "fs";
 import path4 from "path";
 import ora2 from "ora";
 async function init() {
   const spinner = ora2("Initializing").start();
   const configPath = path4.join(process.cwd(), "stacks.config.ts");
   try {
-    await fs3.access(configPath);
+    await fs4.access(configPath);
     spinner.warn("stacks.config.ts already exists");
     return;
-  } catch {
-  }
+  } catch {}
   const hasClarinetProject = await fileExists("./Clarinet.toml");
   let config;
   if (hasClarinetProject) {
-    config = `import { defineConfig } from '@stacks/codegen';
-import { clarinet } from '@stacks/codegen/plugins';
+    config = `import { defineConfig } from '@secondlayer/cli';
+import { clarinet } from '@secondlayer/cli/plugins';
 
 export default defineConfig({
   out: './src/generated/contracts.ts',
@@ -48,93 +41,77 @@ export default defineConfig({
   ]
 });`;
   } else {
-    config = `import { defineConfig } from '@stacks/codegen';
+    config = `import { defineConfig } from '@secondlayer/cli';
 
 export default defineConfig({
   out: './src/generated/contracts.ts',
   plugins: [],
 });`;
   }
-  await fs3.writeFile(configPath, config);
+  await fs4.writeFile(configPath, config);
   spinner.succeed("Created `stacks.config.ts`");
-  console.log(
-    "\nRun `codegen generate` to generate type-safe interfaces, functions, and hooks!"
-  );
+  console.log("\nRun `secondlayer generate` to generate type-safe interfaces, functions, and hooks!");
 }
 async function fileExists(filePath) {
   try {
-    await fs3.access(filePath);
+    await fs4.access(filePath);
     return true;
   } catch {
     return false;
   }
 }
-var init_init = __esm({
-  "src/commands/init.ts"() {
-    "use strict";
-    init_esm_shims();
-  }
-});
+var init_init = () => {};
 
 // src/cli.ts
-init_esm_shims();
 import { program } from "commander";
 
 // src/commands/generate.ts
-init_esm_shims();
+import path3 from "path";
 import chalk from "chalk";
 import ora from "ora";
+var {Glob } = globalThis.Bun;
 
 // src/utils/config.ts
-init_esm_shims();
 import { promises as fs2 } from "fs";
-import path3 from "path";
+import path2 from "path";
 import { pathToFileURL } from "url";
 import { createRequire } from "module";
 import { transformSync } from "esbuild";
 
 // src/core/plugin-manager.ts
-init_esm_shims();
 import { format } from "prettier";
 import { promises as fs } from "fs";
-import path2 from "path";
+import path from "path";
 import { validateStacksAddress } from "@stacks/transactions";
-var PluginManager = class {
+
+class PluginManager {
+  plugins = [];
+  logger;
+  utils;
+  executionContext;
   constructor() {
-    this.plugins = [];
     this.logger = this.createLogger();
     this.utils = this.createUtils();
     this.executionContext = {
       phase: "config",
       startTime: Date.now(),
-      results: /* @__PURE__ */ new Map()
+      results: new Map
     };
   }
-  /**
-   * Register a plugin
-   */
   register(plugin) {
     if (!plugin.name || !plugin.version) {
       throw new Error("Plugin must have a name and version");
     }
     const existing = this.plugins.find((p) => p.name === plugin.name);
     if (existing) {
-      throw new Error(
-        `Plugin "${plugin.name}" is already registered (version ${existing.version})`
-      );
+      throw new Error(`Plugin "${plugin.name}" is already registered (version ${existing.version})`);
     }
     this.plugins.push(plugin);
     this.logger.debug(`Registered plugin: ${plugin.name}@${plugin.version}`);
   }
-  /**
-   * Get all registered plugins
-   */
   getPlugins() {
     return [...this.plugins];
   }
-  /**
-   * Transform user config through all plugins
-   */
   async transformConfig(config) {
     this.executionContext.phase = "config";
     let transformedConfig = { ...config };
@@ -153,9 +130,7 @@ var PluginManager = class {
             success: false,
             error: err
           });
-          throw new Error(
-            `Plugin "${plugin.name}" failed during config transformation: ${err.message}`
-          );
+          throw new Error(`Plugin "${plugin.name}" failed during config transformation: ${err.message}`);
         }
       }
     }
@@ -165,9 +140,6 @@ var PluginManager = class {
     };
     return resolvedConfig;
   }
-  /**
-   * Transform contracts through all plugins
-   */
   async transformContracts(contracts, _config) {
     const processedContracts = [];
     for (let contract of contracts) {
@@ -185,6 +157,20 @@ var PluginManager = class {
         processedContracts.push(processed);
         continue;
       }
+      if (contract._directFile && contract.abi) {
+        const address = typeof contract.address === "string" ? contract.address : "";
+        const [contractAddress, contractName] = address.split(".");
+        const processed = {
+          name: contract.name || contractName,
+          address: contractAddress,
+          contractName,
+          abi: contract.abi,
+          source: "local",
+          metadata: { source: "direct" }
+        };
+        processedContracts.push(processed);
+        continue;
+      }
       for (const plugin of this.plugins) {
         if (plugin.transformContract) {
           this.executionContext.currentPlugin = plugin;
@@ -199,9 +185,7 @@ var PluginManager = class {
               success: false,
               error: err
             });
-            this.logger.warn(
-              `Plugin "${plugin.name}" failed to transform contract: ${err.message}`
-            );
+            this.logger.warn(`Plugin "${plugin.name}" failed to transform contract: ${err.message}`);
           }
         }
       }
@@ -212,7 +196,6 @@ var PluginManager = class {
           contractName: contract.name || "unknown",
           abi: contract.abi,
           source: "api",
-          // Use "api" as default for plugin-processed contracts
           metadata: contract.metadata
         };
         processedContracts.push(processed);
@@ -220,9 +203,6 @@ var PluginManager = class {
     }
     return processedContracts;
   }
-  /**
-   * Execute lifecycle hooks
-   */
   async executeHook(hookName, context) {
     for (const plugin of this.plugins) {
       const hook = plugin[hookName];
@@ -239,19 +219,14 @@ var PluginManager = class {
             success: false,
             error: err
           });
-          this.logger.error(
-            `Plugin "${plugin.name}" failed during ${hookName}: ${err.message}`
-          );
+          this.logger.error(`Plugin "${plugin.name}" failed during ${hookName}: ${err.message}`);
         }
       }
     }
   }
-  /**
-   * Execute generation phase with full context
-   */
   async executeGeneration(contracts, config) {
     this.executionContext.phase = "generate";
-    const outputs = /* @__PURE__ */ new Map();
+    const outputs = new Map;
     const context = {
       config,
       logger: this.logger,
@@ -270,22 +245,16 @@ var PluginManager = class {
     await this.executeHook("afterGenerate", context);
     return outputs;
   }
-  /**
-   * Transform outputs through plugins
-   */
   async transformOutputs(outputs) {
     this.executionContext.phase = "output";
-    const transformedOutputs = /* @__PURE__ */ new Map();
+    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"
-            );
+            transformedContent = await plugin.transformOutput(transformedContent, output.type || "other");
             this.recordHookResult(plugin.name, "transformOutput", {
               success: true
             });
@@ -295,9 +264,7 @@ var PluginManager = class {
               success: false,
               error: err
             });
-            this.logger.warn(
-              `Plugin "${plugin.name}" failed to transform output: ${err.message}`
-            );
+            this.logger.warn(`Plugin "${plugin.name}" failed to transform output: ${err.message}`);
           }
         }
       }
@@ -308,14 +275,11 @@ var PluginManager = class {
     }
     return transformedOutputs;
   }
-  /**
-   * Write outputs to disk
-   */
   async writeOutputs(outputs) {
     for (const [, output] of outputs) {
       try {
-        const resolvedPath = path2.resolve(process.cwd(), output.path);
-        await this.utils.ensureDir(path2.dirname(resolvedPath));
+        const resolvedPath = path.resolve(process.cwd(), output.path);
+        await this.utils.ensureDir(path.dirname(resolvedPath));
         await this.utils.writeFile(resolvedPath, output.content);
       } catch (error) {
         const err = error;
@@ -324,15 +288,9 @@ var PluginManager = class {
       }
     }
   }
-  /**
-   * Get execution results for debugging
-   */
   getExecutionResults() {
     return new Map(this.executionContext.results);
   }
-  /**
-   * Augment existing output with additional content
-   */
   augmentOutput(outputs, outputKey, contractName, content) {
     const existing = outputs.get(outputKey);
     if (!existing) {
@@ -348,18 +306,12 @@ ${JSON.stringify(content, null, 2)}`;
       content: augmentedContent
     });
   }
-  /**
-   * Record hook execution result
-   */
   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);
   }
-  /**
-   * Create logger instance
-   */
   createLogger() {
     return {
       info: (message) => console.log(`\u2139\uFE0F  ${message}`),
@@ -367,15 +319,12 @@ ${JSON.stringify(content, null, 2)}`;
       error: (message) => console.error(`\u274C ${message}`),
       debug: (message) => {
         if (process.env.DEBUG) {
-          console.log(`\u{1F41B} ${message}`);
+          console.log(`\uD83D\uDC1B ${message}`);
         }
       },
       success: (message) => console.log(`\u2705 ${message}`)
     };
   }
-  /**
-   * Create utils instance
-   */
   createUtils() {
     return {
       toCamelCase: (str) => {
@@ -401,7 +350,7 @@ ${JSON.stringify(content, null, 2)}`;
         });
       },
       resolvePath: (relativePath) => {
-        return path2.resolve(process.cwd(), relativePath);
+        return path.resolve(process.cwd(), relativePath);
       },
       fileExists: async (filePath) => {
         try {
@@ -422,32 +371,29 @@ ${JSON.stringify(content, null, 2)}`;
       }
     };
   }
-};
+}
 
 // src/utils/config.ts
 var CONFIG_FILE_NAMES = [
   "stacks.config.ts",
-  "stacks.config.js",
+  "stacks.config",
   "stacks.config.mjs"
 ];
 async function findConfigFile(cwd) {
   for (const fileName of CONFIG_FILE_NAMES) {
-    const filePath = path3.join(cwd, fileName);
+    const filePath = path2.join(cwd, fileName);
     try {
       await fs2.access(filePath);
       return filePath;
-    } catch {
-    }
+    } catch {}
   }
   return null;
 }
 async function loadConfig(configPath) {
   const cwd = process.cwd();
-  const resolvedPath = configPath ? path3.resolve(cwd, configPath) : await findConfigFile(cwd);
+  const resolvedPath = configPath ? path2.resolve(cwd, configPath) : await findConfigFile(cwd);
   if (!resolvedPath) {
-    throw new Error(
-      "No config file found. Create a stacks.config.ts file or specify a path with --config"
-    );
+    throw new Error("No config file found. Create a stacks.config.ts file or specify a path with --config");
   }
   let config;
   if (resolvedPath.endsWith(".ts")) {
@@ -455,17 +401,14 @@ async function loadConfig(configPath) {
     let replacementPath;
     try {
       const require2 = createRequire(import.meta.url);
-      const packagePath = require2.resolve("@stacks/codegen");
+      const packagePath = require2.resolve("@secondlayer/cli");
       replacementPath = pathToFileURL(packagePath).href;
     } catch {
-      const currentModuleDir = path3.dirname(new URL(import.meta.url).pathname);
-      const indexPath = path3.resolve(currentModuleDir, "../index.js");
+      const currentModuleDir = path2.dirname(new URL(import.meta.url).pathname);
+      const indexPath = path2.resolve(currentModuleDir, "../index");
       replacementPath = pathToFileURL(indexPath).href;
     }
-    const transformedCode = code.replace(
-      /from\s+["']@stacks\/cli["']/g,
-      `from '${replacementPath}'`
-    );
+    const transformedCode = code.replace(/from\s+["']@stacks\/cli["']/g, `from '${replacementPath}'`);
     const result = transformSync(transformedCode, {
       format: "esm",
       target: "node18",
@@ -478,8 +421,7 @@ async function loadConfig(configPath) {
       const module = await import(fileUrl);
       config = module.default;
     } finally {
-      await fs2.unlink(tempPath).catch(() => {
-      });
+      await fs2.unlink(tempPath).catch(() => {});
     }
   } else {
     const fileUrl = pathToFileURL(resolvedPath).href;
@@ -493,7 +435,7 @@ async function loadConfig(configPath) {
     config = config({});
   }
   validateConfig(config);
-  const pluginManager = new PluginManager();
+  const pluginManager = new PluginManager;
   if (config.plugins && Array.isArray(config.plugins)) {
     for (const plugin of config.plugins) {
       pluginManager.register(plugin);
@@ -526,22 +468,241 @@ function validateConfig(config) {
 }
 
 // src/utils/api.ts
-init_esm_shims();
 import got from "got";
+var API_URLS = {
+  mainnet: "https://api.hiro.so",
+  testnet: "https://api.testnet.hiro.so",
+  devnet: "http://localhost:3999"
+};
+
+class StacksApiClient {
+  baseUrl;
+  headers;
+  constructor(network = "mainnet", apiKey, apiUrl) {
+    this.baseUrl = apiUrl || API_URLS[network];
+    this.headers = apiKey ? { "x-api-key": apiKey } : {};
+  }
+  async getContractInfo(contractId) {
+    const [address, contractName] = contractId.split(".");
+    if (!address || !contractName) {
+      throw new Error(`Invalid contract ID format: ${contractId}. Expected format: ADDRESS.CONTRACT_NAME`);
+    }
+    const url = `${this.baseUrl}/v2/contracts/interface/${address}/${contractName}`;
+    try {
+      const response = await got(url, {
+        headers: this.headers,
+        responseType: "json"
+      });
+      return response.body;
+    } catch (error) {
+      if (error.response?.statusCode === 404) {
+        throw new Error(`Contract not found: ${contractId}`);
+      }
+      if (error.response?.statusCode === 429) {
+        throw new Error("Rate limited. Please provide an API key in your config.");
+      }
+      throw new Error(`Failed to fetch contract: ${error.message}`);
+    }
+  }
+  async getContractSource(contractId) {
+    const [address, contractName] = contractId.split(".");
+    if (!address || !contractName) {
+      throw new Error(`Invalid contract ID format: ${contractId}. Expected format: ADDRESS.CONTRACT_NAME`);
+    }
+    const url = `${this.baseUrl}/v2/contracts/source/${address}/${contractName}`;
+    try {
+      const response = await got(url, {
+        headers: this.headers,
+        responseType: "json"
+      });
+      const data = response.body;
+      return data.source;
+    } catch (error) {
+      return "";
+    }
+  }
+}
 
 // src/parsers/clarity.ts
-init_esm_shims();
+import { promises as fs3 } from "fs";
+async function parseClarityFile(filePath) {
+  const content = await fs3.readFile(filePath, "utf-8");
+  return parseClarityContent(content);
+}
+function parseClarityContent(content) {
+  const functions = [];
+  const functionRegex = /\(define-(public|read-only|private)\s+\(([^)]+)\)([\s\S]*?)\)\s*$/gm;
+  let match;
+  while ((match = functionRegex.exec(content)) !== null) {
+    const [, access, signature, body] = match;
+    const func = parseFunctionSignature(signature, access, body);
+    if (func) {
+      functions.push(func);
+    }
+  }
+  return { functions };
+}
+function parseFunctionSignature(signature, access, body) {
+  const parts = signature.trim().split(/\s+/);
+  const name = parts[0];
+  const args = [];
+  for (let i = 1;i < parts.length; i += 2) {
+    if (parts[i] && parts[i + 1]) {
+      const argName = parts[i].replace(/[()]/g, "");
+      const argType = parseType(parts[i + 1]);
+      if (argType) {
+        args.push({ name: argName, type: argType });
+      }
+    }
+  }
+  const outputs = inferReturnType(body);
+  return {
+    name,
+    access,
+    args,
+    outputs
+  };
+}
+function parseType(typeStr) {
+  typeStr = typeStr.replace(/[()]/g, "").trim();
+  switch (typeStr) {
+    case "uint":
+    case "uint128":
+      return "uint128";
+    case "int":
+    case "int128":
+      return "int128";
+    case "bool":
+      return "bool";
+    case "principal":
+      return "principal";
+    case "trait_reference":
+      return "principal";
+    default:
+      if (typeStr.startsWith("string-ascii")) {
+        return { "string-ascii": { length: 256 } };
+      }
+      if (typeStr.startsWith("string-utf8")) {
+        return { "string-utf8": { length: 256 } };
+      }
+      if (typeStr.startsWith("buff")) {
+        return { buff: { length: 32 } };
+      }
+      return "uint128";
+  }
+}
+function inferReturnType(body) {
+  if (body.includes("(ok")) {
+    if (body.includes("(err")) {
+      return {
+        response: {
+          ok: "bool",
+          error: "uint128"
+        }
+      };
+    }
+  }
+  if (body.includes("true") || body.includes("false")) {
+    return "bool";
+  }
+  return "bool";
+}
+function parseApiResponse(apiResponse) {
+  try {
+    const functions = [];
+    if (apiResponse.functions) {
+      for (const func of apiResponse.functions) {
+        const access = func.access === "read_only" ? "read-only" : func.access;
+        functions.push({
+          name: func.name,
+          access,
+          args: func.args.map((arg) => ({
+            name: arg.name,
+            type: convertApiType(arg.type)
+          })),
+          outputs: convertApiType(func.outputs.type)
+        });
+      }
+    }
+    return { functions };
+  } catch (error) {
+    throw new Error(`Failed to parse API response: ${error}`);
+  }
+}
+function convertApiType(apiType) {
+  if (typeof apiType === "string") {
+    if (apiType === "trait_reference") {
+      return "trait_reference";
+    }
+    return parseType(apiType) || "uint128";
+  }
+  if (apiType.response) {
+    return {
+      response: {
+        ok: convertApiType(apiType.response.ok),
+        error: convertApiType(apiType.response.error)
+      }
+    };
+  }
+  if (apiType.optional) {
+    return {
+      optional: convertApiType(apiType.optional)
+    };
+  }
+  if (apiType.list) {
+    return {
+      list: {
+        type: convertApiType(apiType.list.type),
+        length: apiType.list.length || 100
+      }
+    };
+  }
+  if (apiType.tuple) {
+    return {
+      tuple: apiType.tuple.map((field) => ({
+        name: field.name,
+        type: convertApiType(field.type)
+      }))
+    };
+  }
+  if (apiType.buffer) {
+    return {
+      buff: {
+        length: apiType.buffer.length || 32
+      }
+    };
+  }
+  if (apiType["string-ascii"]) {
+    return {
+      "string-ascii": {
+        length: apiType["string-ascii"].length || 256
+      }
+    };
+  }
+  if (apiType["string-utf8"]) {
+    return {
+      "string-utf8": {
+        length: apiType["string-utf8"].length || 256
+      }
+    };
+  }
+  if (apiType === "none") {
+    return "uint128";
+  }
+  return "uint128";
+}
 
 // src/generators/contract.ts
-init_esm_shims();
 import { format as format2 } from "prettier";
 async function generateContractInterface(contracts) {
   const imports = `import { Cl, validateStacksAddress } from '@stacks/transactions'`;
   const header = `/**
- * Generated by @stacks/codegen
+ * Generated by @secondlayer/cli
  * DO NOT EDIT MANUALLY
  */`;
-  const contractsCode = contracts.map((contract) => generateContract(contract)).join("\n\n");
+  const contractsCode = contracts.map((contract) => generateContract(contract)).join(`
+
+`);
   const code = `${imports}
 
 ${header}
@@ -559,7 +720,9 @@ ${contractsCode}`;
 function generateContract(contract) {
   const { name, address, contractName, abi } = contract;
   const abiCode = generateAbiConstant(name, abi);
-  const methods = abi.functions.filter((func) => func.access !== "private").map((func) => generateMethod(func, address, contractName)).join(",\n\n  ");
+  const methods = abi.functions.filter((func) => func.access !== "private").map((func) => generateMethod(func, address, contractName)).join(`,
+
+  `);
   const contractCode = `export const ${name} = {
   address: '${address}',
   contractAddress: '${address}',
@@ -663,9 +826,7 @@ function getTypeForArg(arg) {
     return `${innerType}[]`;
   }
   if (type.tuple) {
-    const fields = type.tuple.map(
-      (field) => `${toCamelCase(field.name)}: ${getTypeForArg({ type: field.type })}`
-    ).join("; ");
+    const fields = type.tuple.map((field) => `${toCamelCase(field.name)}: ${getTypeForArg({ type: field.type })}`).join("; ");
     return `{ ${fields} }`;
   }
   if (type.response) {
@@ -762,10 +923,7 @@ function generateClarityConversion(argName, argType) {
   if (type.tuple) {
     const fields = type.tuple.map((field) => {
       const camelFieldName = toCamelCase(field.name);
-      const fieldConversion = generateClarityConversion(
-        `${argName}.${camelFieldName}`,
-        { type: field.type }
-      );
+      const fieldConversion = generateClarityConversion(`${argName}.${camelFieldName}`, { type: field.type });
       return `"${field.name}": ${fieldConversion}`;
     }).join(", ");
     return `Cl.tuple({ ${fields} })`;
@@ -783,43 +941,144 @@ function generateClarityConversion(argName, argType) {
 }
 
 // src/commands/generate.ts
-async function generate(options) {
+function isContractAddress(input) {
+  const contractIdPattern = /^(SP|ST|SM|SN)[A-Z0-9]{38,}\.[a-zA-Z][a-zA-Z0-9-]*$/;
+  return contractIdPattern.test(input);
+}
+function inferNetwork(address) {
+  if (address.startsWith("SP") || address.startsWith("SM")) {
+    return "mainnet";
+  }
+  return "testnet";
+}
+async function parseInputs(inputs) {
+  const files = [];
+  const contractIds = [];
+  for (const input of inputs) {
+    if (isContractAddress(input)) {
+      contractIds.push(input);
+      continue;
+    }
+    if (input.includes("*") || input.includes("?")) {
+      const glob = new Glob(input);
+      for await (const file of glob.scan({ cwd: process.cwd(), absolute: true })) {
+        if (file.endsWith(".clar")) {
+          files.push(file);
+        }
+      }
+      continue;
+    }
+    if (input.endsWith(".clar")) {
+      const absolutePath = path3.resolve(process.cwd(), input);
+      files.push(absolutePath);
+    }
+  }
+  return {
+    files: [...new Set(files)],
+    contractIds: [...new Set(contractIds)]
+  };
+}
+function deriveContractName(filePath) {
+  const basename = path3.basename(filePath, ".clar");
+  return basename.replace(/[-_](.)/g, (_, char) => char.toUpperCase()).replace(/^(.)/, (_, char) => char.toLowerCase()).replace(/^\d/, "_$&");
+}
+function toCamelCase2(str) {
+  return str.replace(/[-_](.)/g, (_, char) => char.toUpperCase()).replace(/^(.)/, (_, char) => char.toLowerCase()).replace(/^\d/, "_$&");
+}
+async function buildConfigFromInputs(parsedInputs, outPath, apiKey, spinner) {
+  const contracts = [];
+  for (const file of parsedInputs.files) {
+    const abi = await parseClarityFile(file);
+    const name = deriveContractName(file);
+    contracts.push({
+      name,
+      address: `ST1PQHQKV0RJXZFY1DGX8MNSNYVE3VGZJSRTPGZGM.${name}`,
+      abi,
+      _directFile: true
+    });
+  }
+  for (const contractId of parsedInputs.contractIds) {
+    const [address, contractName] = contractId.split(".");
+    const network = inferNetwork(address);
+    spinner.text = `Fetching ${contractName} from ${network}...`;
+    try {
+      const apiClient = new StacksApiClient(network, apiKey);
+      const contractInfo = await apiClient.getContractInfo(contractId);
+      const abi = parseApiResponse(contractInfo);
+      const name = toCamelCase2(contractName);
+      contracts.push({
+        name,
+        address: contractId,
+        abi,
+        _directFile: true
+      });
+    } catch (error) {
+      throw new Error(`Failed to fetch contract ${contractId}: ${error.message}`);
+    }
+  }
+  return {
+    out: outPath,
+    contracts,
+    plugins: []
+  };
+}
+async function generate(files, options) {
   const spinner = ora("Processing contracts").start();
   try {
-    const config = await loadConfig(options.config);
-    const pluginManager = new PluginManager();
+    let config;
+    if (files && files.length > 0) {
+      if (!options.out) {
+        spinner.fail("Output path required");
+        console.error(chalk.red(`
+When using direct inputs, you must specify an output path with -o/--out`));
+        console.log(chalk.gray(`
+Examples:`));
+        console.log(chalk.gray("  secondlayer generate ./contracts/*.clar -o ./src/generated.ts"));
+        console.log(chalk.gray("  secondlayer generate SP2C2YFP12AJZB1M6DY7SF9A3PRHWKGYGVWQKW3.my-token -o ./src/generated.ts"));
+        process.exit(1);
+      }
+      const parsedInputs = await parseInputs(files);
+      const totalInputs = parsedInputs.files.length + parsedInputs.contractIds.length;
+      if (totalInputs === 0) {
+        spinner.fail("No valid inputs found");
+        console.error(chalk.red(`
+No .clar files or contract addresses matched the provided inputs`));
+        process.exit(1);
+      }
+      spinner.text = `Processing ${totalInputs} contract(s)...`;
+      const apiKey = options.apiKey || process.env.HIRO_API_KEY;
+      config = await buildConfigFromInputs(parsedInputs, options.out, apiKey, spinner);
+    } else {
+      config = await loadConfig(options.config);
+    }
+    const pluginManager = new PluginManager;
     if (config.plugins) {
       for (const plugin of config.plugins) {
         pluginManager.register(plugin);
       }
     }
-    await pluginManager.executeHook("configResolved", config);
-    const contractConfigs = (config.contracts || []).map(
-      (contract) => ({
-        name: contract.name,
-        address: contract.address,
-        source: contract.source,
-        abi: contract.abi,
-        // Include ABI if it exists (from plugins)
-        _clarinetSource: contract._clarinetSource
-        // Include plugin flags
-      })
-    );
-    const processedContracts = await pluginManager.transformContracts(
-      contractConfigs,
-      config
-    );
+    const resolvedConfig = {
+      ...config,
+      plugins: pluginManager.getPlugins()
+    };
+    await pluginManager.executeHook("configResolved", resolvedConfig);
+    const contractConfigs = (config.contracts || []).map((contract) => ({
+      name: contract.name,
+      address: contract.address,
+      source: contract.source,
+      abi: contract.abi,
+      _clarinetSource: contract._clarinetSource
+    }));
+    const processedContracts = await pluginManager.transformContracts(contractConfigs, resolvedConfig);
     if (processedContracts.length === 0) {
       spinner.warn("No contracts found to generate");
-      console.log("\nTo get started:");
+      console.log(`
+To get started:`);
       console.log("  \u2022 Add contracts to your config file, or");
       console.log("  \u2022 Use plugins like clarinet() for local contracts");
       return;
     }
-    const outputs = await pluginManager.executeGeneration(
-      processedContracts,
-      config
-    );
+    const outputs = await pluginManager.executeGeneration(processedContracts, resolvedConfig);
     if (!outputs.has("contracts") && processedContracts.length > 0) {
       const contractsCode = await generateContractInterface(processedContracts);
       outputs.set("contracts", {
@@ -834,22 +1093,14 @@ async function generate(options) {
     const contractWord = contractCount === 1 ? "contract" : "contracts";
     spinner.succeed(`Generation complete for ${contractCount} ${contractWord}`);
     console.log(`
-\u{1F4C4} ${config.out}`);
+\uD83D\uDCC4 ${config.out}`);
     console.log(`
-\u{1F4A1} Import your contracts:`);
+\uD83D\uDCA1 Import your contracts:`);
     if (processedContracts.length > 0) {
       const exampleContract = processedContracts[0];
-      console.log(
-        chalk.gray(
-          `   import { ${exampleContract.name} } from '${config.out.replace(/\.ts$/, "")}'`
-        )
-      );
+      console.log(chalk.gray(`   import { ${exampleContract.name} } from '${config.out.replace(/\.ts$/, "")}'`));
       if (processedContracts.length > 1) {
-        console.log(
-          chalk.gray(
-            `   // Also available: ${processedContracts.slice(1).map((c) => c.name).join(", ")}`
-          )
-        );
+        console.log(chalk.gray(`   // Also available: ${processedContracts.slice(1).map((c) => c.name).join(", ")}`));
       }
     }
   } catch (error) {
@@ -865,10 +1116,12 @@ ${error.message}`));
 
 // src/cli.ts
 program.name("stacks").description("CLI tool for generating type-safe Stacks contract interfaces").version("0.1.0");
-program.command("generate").alias("gen").description("Generate TypeScript interfaces from Clarity contracts").option("-c, --config <path>", "Path to config file").option("-w, --watch", "Watch for changes").action(generate);
+program.command("generate [files...]").alias("gen").description("Generate TypeScript interfaces from Clarity contracts").option("-c, --config <path>", "Path to config file").option("-o, --out <path>", "Output file path (required when using direct files)").option("-k, --api-key <key>", "Hiro API key (or set HIRO_API_KEY env var)").option("-w, --watch", "Watch for changes").action(generate);
 program.command("init").description("Initialize a new stacks.config.ts file").action(async () => {
-  const { init: init2 } = await Promise.resolve().then(() => (init_init(), init_exports));
+  const { init: init2 } = await Promise.resolve().then(() => (init_init(), exports_init));
   await init2();
 });
 program.parse();
-//# sourceMappingURL=cli.js.map
+
+//# debugId=5EBBA30969CCC98F64756E2164756E21
+//# sourceMappingURL=cli.js.map