fix: regenerate workspace Cargo.lock after extension overlay (contracts/ layout) (#13)

* fix: generate missing Cargo.lock after extension overlay

The erc-20 extension ships contracts/erc20-example/Cargo.toml but no
Cargo.lock. cargo-stylus 0.10.x runs cargo build --locked internally,
which hard-fails when no lock file exists.

New task `refreshCargoLocks` runs after copyTemplateFiles and before
install. It finds every Cargo.toml directory under packages/stylus/
that is missing a Cargo.lock and generates one via `cargo metadata
--format-version 1` (offline-first, online fallback). Empirically
verified: parity-scale-codec resolves to 3.7.5 in all lock files.
Task warns-and-continues if cargo is not on PATH; base scaffold with
no extension is unaffected (existing locks are skipped).

* fix: update Cargo.lock refresh for contracts/ workspace layout

- Fix isYourContract regex to match new packages/stylus/contracts/your-contract path
  so your-contract is correctly skipped when an extension is used
- Refresh Cargo.lock for all found contract/workspace dirs, not just missing ones,
  so a stale workspace lock is updated after extension overlay adds new members

Author: tu11aa

src/main.ts

@@ -5,6 +5,7 @@ import {
   createFirstGitCommit,
   prettierFormat,
   setConfigNetworkToSepolia,
+  refreshCargoLocks,
 } from "./tasks";
 import type { Options } from "./types";
 import { renderOutroMessage } from "./utils/render-outro-message";
@@ -57,6 +58,10 @@ export async function createProject(options: Options) {
           }
         },
       },
+      {
+        title: `🔒 Refreshing Cargo.lock for contracts`,
+        task: async () => await refreshCargoLocks(targetDirectory),
+      },
       {
         title: `📦 Installing dependencies with yarn, this could take a while`,
         task: async (ctx, task) => {

src/tasks/copy-template-files.ts

@@ -41,7 +41,7 @@ const copyBaseFiles = async (
       const isYarnLock = isYarnLockRegex.test(fileName);
       const isNextGenerated = isNextGeneratedRegex.test(fileName);
       const isGitKeep = isGitKeepRegex.test(fileName);
-      const isYourContract = /packages\/stylus\/your-contract/.test(fileName);
+      const isYourContract = /packages\/stylus\/contracts\/your-contract/.test(fileName);
 
       // Check if file matches any exclude pattern
       const isExcluded = excludePatterns.some(pattern => pattern.test(fileName));

src/tasks/index.ts

@@ -4,3 +4,4 @@ export * from "./install-packages";
 export * from "./create-first-git-commit";
 export * from "./prettier-format";
 export * from "./config-to-sepolia";
+export * from "./refresh-cargo-lock";

src/tasks/refresh-cargo-lock.ts

@@ -0,0 +1,68 @@
+import { execa } from "execa";
+import fs from "fs";
+import path from "path";
+
+const SKIP_DIRS = new Set([".git", "target", "node_modules", ".cargo"]);
+
+function findContractDirs(dir: string): string[] {
+  const result: string[] = [];
+
+  let entries: fs.Dirent[];
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return result;
+  }
+
+  for (const entry of entries) {
+    if (!entry.isDirectory() || SKIP_DIRS.has(entry.name)) continue;
+    const fullPath = path.join(dir, entry.name);
+
+    if (fs.existsSync(path.join(fullPath, "Cargo.toml"))) {
+      result.push(fullPath);
+    } else {
+      result.push(...findContractDirs(fullPath));
+    }
+  }
+
+  return result;
+}
+
+export async function refreshCargoLocks(targetDir: string) {
+  const stylusDir = path.join(targetDir, "packages", "stylus");
+
+  if (!fs.existsSync(stylusDir)) return;
+
+  const contractDirs = findContractDirs(stylusDir);
+
+  if (contractDirs.length === 0) return;
+
+  for (const contractDir of contractDirs) {
+    try {
+      try {
+        await execa(
+          "cargo",
+          ["metadata", "--format-version", "1", "--offline"],
+          { cwd: contractDir, stdio: "pipe" }
+        );
+      } catch {
+        await execa("cargo", ["metadata", "--format-version", "1"], {
+          cwd: contractDir,
+          stdio: "pipe",
+        });
+      }
+    } catch (error: any) {
+      const isNotFound = error?.code === "ENOENT";
+      const label = path.relative(targetDir, contractDir);
+      if (isNotFound) {
+        console.warn(
+          `\n[warn] cargo not found on PATH — skipping Cargo.lock refresh for ${label}`
+        );
+      } else {
+        console.warn(
+          `\n[warn] Could not refresh Cargo.lock for ${label}: ${error?.message ?? error}`
+        );
+      }
+    }
+  }
+}