@impulselab/cli 0.1.0 → 0.1.1

package/dist/index.js

@@ -71,6 +71,11 @@ var ULTIMATE_TEMPLATE_MARKERS = [
   "@impulselab/ultimate-template",
   "ultimate-template"
 ];
+var STRUCTURAL_MARKERS = {
+  requiredDirs: ["packages/server", "packages/database"],
+  requiredFiles: ["turbo.json", "pnpm-workspace.yaml"],
+  workspaceDeps: ["@orpc/server", "drizzle-orm", "better-auth"]
+};
 async function detectProjectName(cwd) {
   const pkgPath = path2.join(cwd, "package.json");
   if (await pathExists3(pkgPath)) {
@@ -81,6 +86,18 @@ async function detectProjectName(cwd) {
   }
   return path2.basename(cwd);
 }
+function getDeps(pkg) {
+  const deps = /* @__PURE__ */ new Set();
+  for (const key of ["dependencies", "devDependencies"]) {
+    const d = pkg[key];
+    if (d && typeof d === "object") {
+      for (const name of Object.keys(d)) {
+        deps.add(name);
+      }
+    }
+  }
+  return deps;
+}
 async function isUltimateTemplate(cwd) {
   const pkgPath = path2.join(cwd, "package.json");
   if (!await pathExists3(pkgPath)) return false;
@@ -93,7 +110,40 @@ async function isUltimateTemplate(cwd) {
   const keywordMatches = ULTIMATE_TEMPLATE_MARKERS.some(
     (m) => keywords.includes(m)
   );
-  return nameMatches || keywordMatches;
+  if (nameMatches || keywordMatches) return true;
+  if (pkg["impulseTemplate"] === true) return true;
+  const hasRequiredFiles = (await Promise.all(
+    STRUCTURAL_MARKERS.requiredFiles.map(
+      (f) => pathExists3(path2.join(cwd, f))
+    )
+  )).every(Boolean);
+  if (!hasRequiredFiles) return false;
+  const hasRequiredDirs = (await Promise.all(
+    STRUCTURAL_MARKERS.requiredDirs.map(
+      (d) => pathExists3(path2.join(cwd, d))
+    )
+  )).every(Boolean);
+  if (!hasRequiredDirs) return false;
+  const workspaceDirs = ["packages", "apps"];
+  const foundDeps = /* @__PURE__ */ new Set();
+  for (const dir of workspaceDirs) {
+    const dirPath = path2.join(cwd, dir);
+    if (!await pathExists3(dirPath)) continue;
+    const { readdir } = await import("fs/promises");
+    const entries = await readdir(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const childPkg = path2.join(dirPath, entry.name, "package.json");
+      if (!await pathExists3(childPkg)) continue;
+      const childRaw = await readJson2(childPkg);
+      if (!childRaw || typeof childRaw !== "object") continue;
+      const deps = getDeps(childRaw);
+      for (const dep of STRUCTURAL_MARKERS.workspaceDeps) {
+        if (deps.has(dep)) foundDeps.add(dep);
+      }
+    }
+  }
+  return foundDeps.size >= STRUCTURAL_MARKERS.workspaceDeps.length;
 }
 async function runInit(options) {
   const { cwd, force } = options;
@@ -145,7 +195,7 @@ async function runInit(options) {
 }
 
 // src/commands/add.ts
-import { execSync, execFileSync } from "child_process";
+import { execSync as execSync2, execFileSync } from "child_process";
 import { existsSync } from "fs";
 import path11 from "path";
 import * as p4 from "@clack/prompts";
@@ -201,6 +251,7 @@ var ModuleManifestSchema = z5.object({
 });
 
 // src/registry/github-urls.ts
+import { execSync } from "child_process";
 var GITHUB_ORG = "impulse-studio";
 var GITHUB_REPO = "impulse-modules";
 var GITHUB_BRANCH = "main";
@@ -210,6 +261,33 @@ var githubUrls = {
   moduleList: () => `https://api.github.com/repos/${GITHUB_ORG}/${GITHUB_REPO}/contents/${MODULES_DIR}`,
   subModulesList: (parentModule) => `https://api.github.com/repos/${GITHUB_ORG}/${GITHUB_REPO}/contents/${MODULES_DIR}/${parentModule}/sub-modules`
 };
+var _cachedToken;
+function getGitHubToken() {
+  if (_cachedToken !== void 0) return _cachedToken;
+  const envToken = process.env.GITHUB_TOKEN;
+  if (envToken) {
+    _cachedToken = envToken;
+    return envToken;
+  }
+  try {
+    const token = execSync("gh auth token", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    if (token) {
+      _cachedToken = token;
+      return token;
+    }
+  } catch {
+  }
+  _cachedToken = null;
+  return null;
+}
+function getGitHubHeaders(extra) {
+  const headers = { ...extra };
+  const token = getGitHubToken();
+  if (token) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  return headers;
+}
 
 // src/registry/parse-module-id.ts
 function parseModuleId(moduleId) {
@@ -243,7 +321,7 @@ async function fetchModuleManifest(moduleId, localPath) {
     return parsed2.data;
   }
   const url = githubUrls.rawFile(registryPath, "module.json");
-  const res = await fetch(url);
+  const res = await fetch(url, { headers: getGitHubHeaders() });
   if (!res.ok) {
     if (res.status === 404) {
       throw new Error(`Module not found in registry: ${moduleId}`);
@@ -295,7 +373,7 @@ async function listAvailableModules(localPath) {
   }
   if (_cachedModuleList) return _cachedModuleList;
   const res = await fetch(githubUrls.moduleList(), {
-    headers: { Accept: "application/vnd.github.v3+json" }
+    headers: getGitHubHeaders({ Accept: "application/vnd.github.v3+json" })
   });
   if (!res.ok) {
     throw new Error(`Failed to fetch module list: ${res.status} ${res.statusText}`);
@@ -314,7 +392,7 @@ async function listAvailableModules(localPath) {
     baseModules.map(async (mod) => {
       try {
         const subRes = await fetch(githubUrls.subModulesList(mod.name), {
-          headers: { Accept: "application/vnd.github.v3+json" }
+          headers: getGitHubHeaders({ Accept: "application/vnd.github.v3+json" })
         });
         if (!subRes.ok) return mod;
         const subEntries = await subRes.json();
@@ -341,7 +419,7 @@ async function fetchModuleFile(moduleName, fileSrc, localPath) {
     return readFile6(file, "utf-8");
   }
   const url = githubUrls.rawFile(moduleName, fileSrc);
-  const res = await fetch(url);
+  const res = await fetch(url, { headers: getGitHubHeaders() });
   if (!res.ok) {
     throw new Error(`Failed to fetch file ${fileSrc} for module ${moduleName}: ${res.status}`);
   }
@@ -767,7 +845,7 @@ Available: ${parentManifest.subModules.join(", ")}`
       p4.log.step(`Running post-install hooks for ${name}...`);
       for (const hook of hooks) {
         p4.log.message(`  $ ${hook}`);
-        execSync(hook, { cwd, stdio: "inherit" });
+        execSync2(hook, { cwd, stdio: "inherit" });
       }
     }
   }
@@ -778,7 +856,7 @@ Available: ${parentManifest.subModules.join(", ")}`
       p4.log.step(`Running post-install hooks for ${targetId}...`);
       for (const hook of targetManifest.postInstall) {
         p4.log.message(`  $ ${hook}`);
-        execSync(hook, { cwd, stdio: "inherit" });
+        execSync2(hook, { cwd, stdio: "inherit" });
       }
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@impulselab/cli",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "ImpulseLab CLI — install and manage modules for your projects",
   "private": false,
   "type": "module",
@@ -8,13 +8,16 @@
   "bin": {
     "impulse": "dist/index.js"
   },
-  "scripts": {
-    "prepublishOnly": "pnpm run build",
-    "publish:npm": "npm publish --access public",
-    "build": "tsup src/index.ts --format esm --target es2022 --dts",
-    "dev": "tsup src/index.ts --format esm --target es2022 --watch",
-    "lint": "oxlint .",
-    "test": "vitest run"
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/impulse-studio/impulse-modules",
+    "directory": "cli"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
@@ -29,5 +32,11 @@
     "commander": "^14.0.3",
     "fs-extra": "^11.3.4",
     "zod": "^4.3.6"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --target es2022 --dts",
+    "dev": "tsup src/index.ts --format esm --target es2022 --watch",
+    "lint": "oxlint .",
+    "test": "vitest run"
   }
-}
+}

package/src/commands/add.test.ts

@@ -1,147 +0,0 @@
-/**
- * Tests for sub-module resolution logic in the add command.
- * Uses a local modules fixture directory to avoid network calls.
- */
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { mkdtemp, rm, mkdir } from "fs/promises";
-import { outputJson } from "fs-extra";
-import path from "path";
-import os from "os";
-import { parseModuleId } from "../registry/index";
-
-// Re-export parseModuleId through the test as a sanity check
-describe("parseModuleId integration", () => {
-  it("correctly identifies sub-module ids", () => {
-    const { parent, child } = parseModuleId("attio/gocardless");
-    expect(parent).toBe("attio");
-    expect(child).toBe("gocardless");
-  });
-
-  it("correctly identifies top-level ids", () => {
-    const { parent, child } = parseModuleId("attio");
-    expect(parent).toBe("attio");
-    expect(child).toBeNull();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// resolveWithParent behaviour — validated via fetchModuleManifest + local fixtures
-// ---------------------------------------------------------------------------
-
-let tmpDir: string;
-let localModules: string;
-
-beforeEach(async () => {
-  tmpDir = await mkdtemp(path.join(os.tmpdir(), "impulse-add-test-"));
-  localModules = path.join(tmpDir, "modules");
-});
-
-afterEach(async () => {
-  await rm(tmpDir, { recursive: true, force: true });
-});
-
-async function writeManifest(dir: string, manifest: Record<string, unknown>): Promise<void> {
-  await mkdir(dir, { recursive: true });
-  await outputJson(path.join(dir, "module.json"), manifest);
-}
-
-describe("sub-module dependency resolution (via fetchModuleManifest)", () => {
-  it("resolves parent manifest when installing a sub-module", async () => {
-    const { fetchModuleManifest } = await import("../registry/index");
-
-    await writeManifest(path.join(localModules, "attio"), {
-      name: "attio",
-      version: "1.0.0",
-      description: "Attio",
-      subModules: ["quote-to-cash", "gocardless"],
-      files: [],
-      transforms: [],
-    });
-    await writeManifest(
-      path.join(localModules, "attio", "sub-modules", "quote-to-cash"),
-      {
-        name: "attio/quote-to-cash",
-        version: "1.0.0",
-        description: "Quote-to-cash",
-        parentModule: "attio",
-        files: [],
-        transforms: [],
-      }
-    );
-
-    const parentManifest = await fetchModuleManifest("attio", localModules);
-    expect(parentManifest.name).toBe("attio");
-    expect(parentManifest.subModules).toContain("quote-to-cash");
-
-    const subManifest = await fetchModuleManifest("attio/quote-to-cash", localModules);
-    expect(subManifest.parentModule).toBe("attio");
-    expect(subManifest.name).toBe("attio/quote-to-cash");
-  });
-
-  it("installs multiple --with sub-modules (validates all IDs resolvable)", async () => {
-    const { fetchModuleManifest } = await import("../registry/index");
-
-    await writeManifest(path.join(localModules, "attio"), {
-      name: "attio",
-      version: "1.0.0",
-      description: "Attio",
-      subModules: ["quote-to-cash", "gocardless", "pennylane"],
-      files: [],
-      transforms: [],
-    });
-
-    const subNames = ["quote-to-cash", "gocardless", "pennylane"];
-    for (const sub of subNames) {
-      await writeManifest(
-        path.join(localModules, "attio", "sub-modules", sub),
-        {
-          name: `attio/${sub}`,
-          version: "1.0.0",
-          description: sub,
-          parentModule: "attio",
-          files: [],
-          transforms: [],
-        }
-      );
-    }
-
-    // Verify each sub-module can be fetched via slash syntax
-    for (const sub of subNames) {
-      const manifest = await fetchModuleManifest(`attio/${sub}`, localModules);
-      expect(manifest.parentModule).toBe("attio");
-    }
-  });
-
-  it("auto-dependency: sub-module declares parent in moduleDependencies", async () => {
-    const { fetchModuleManifest } = await import("../registry/index");
-
-    await writeManifest(path.join(localModules, "attio"), {
-      name: "attio",
-      version: "1.0.0",
-      description: "Attio",
-      subModules: ["gocardless"],
-      files: [],
-      transforms: [],
-    });
-    await writeManifest(
-      path.join(localModules, "attio", "sub-modules", "gocardless"),
-      {
-        name: "attio/gocardless",
-        version: "1.0.0",
-        description: "GoCardless",
-        parentModule: "attio",
-        moduleDependencies: [],
-        files: [],
-        transforms: [],
-      }
-    );
-
-    // The parent manifest should be valid
-    const parent = await fetchModuleManifest("attio", localModules);
-    expect(parent.subModules).toContain("gocardless");
-
-    // The sub-module should have parentModule set
-    const sub = await fetchModuleManifest("attio/gocardless", localModules);
-    expect(sub.parentModule).toBe("attio");
-  });
-});

package/src/commands/add.ts

@@ -1,335 +0,0 @@
-import { execSync, execFileSync } from "child_process";
-import { existsSync } from "fs";
-import path from "path";
-import * as p from "@clack/prompts";
-import { readConfig, writeConfig } from "../config/index";
-import { fetchModuleManifest, parseModuleId } from "../registry/index";
-import { installFiles } from "../installer";
-import { runTransform } from "../transforms/index";
-import type { ModuleManifest } from "../types";
-import type { ImpulseConfig } from "../schemas/impulse-config";
-
-async function resolveModuleDeps(
-  moduleId: string,
-  localPath: string | undefined,
-  resolved: Set<string>,
-  orderedModules: string[]
-): Promise<void> {
-  if (resolved.has(moduleId)) return;
-  resolved.add(moduleId);
-
-  const manifest = await fetchModuleManifest(moduleId, localPath);
-  for (const dep of manifest.moduleDependencies) {
-    await resolveModuleDeps(dep, localPath, resolved, orderedModules);
-  }
-  orderedModules.push(moduleId);
-}
-
-/**
- * For a sub-module install (`parent/child`), ensure the parent module itself
- * is resolved first if it is not already installed.
- */
-async function resolveWithParent(
-  moduleId: string,
-  localPath: string | undefined,
-  installedNames: Set<string>,
-  resolved: Set<string>,
-  orderedModules: string[]
-): Promise<void> {
-  const { parent, child } = parseModuleId(moduleId);
-  if (child !== null && !installedNames.has(parent)) {
-    await resolveModuleDeps(parent, localPath, resolved, orderedModules);
-  }
-  await resolveModuleDeps(moduleId, localPath, resolved, orderedModules);
-}
-
-function detectPackageManager(cwd: string): "pnpm" | "npm" | "yarn" {
-  if (existsSync(path.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (existsSync(path.join(cwd, "yarn.lock"))) return "yarn";
-  return "npm";
-}
-
-function installNpmDeps(
-  deps: string[],
-  cwd: string,
-  dryRun: boolean
-): void {
-  if (deps.length === 0) return;
-  const pm = detectPackageManager(cwd);
-  const args = ["add", ...deps];
-
-  if (dryRun) {
-    p.log.info(`[dry-run] Would run: ${pm} ${args.join(" ")}`);
-    return;
-  }
-
-  p.log.step(`Installing dependencies: ${deps.join(", ")}`);
-  execFileSync(pm, args, { cwd, stdio: "inherit" });
-}
-
-async function installModule(
-  moduleId: string,
-  manifest: ModuleManifest,
-  cwd: string,
-  dryRun: boolean,
-  localPath?: string
-): Promise<void> {
-  p.log.step(`Installing ${moduleId}@${manifest.version}...`);
-
-  if (manifest.files.length > 0) {
-    const installed = await installFiles({
-      moduleName: moduleId,
-      files: manifest.files,
-      cwd,
-      dryRun,
-      localPath,
-    });
-
-    for (const f of installed) {
-      const icon =
-        f.action === "created" || f.action === "would-create"
-          ? "+"
-          : f.action === "overwritten" || f.action === "would-overwrite"
-          ? "~"
-          : "=";
-      p.log.message(`  ${icon} ${f.dest}`);
-    }
-  }
-
-  for (const transform of manifest.transforms) {
-    p.log.step(`  transform: ${transform.type} → ${transform.target}`);
-    await runTransform(transform, cwd, dryRun);
-  }
-}
-
-function recordModule(
-  config: ImpulseConfig,
-  moduleId: string,
-  manifest: ModuleManifest,
-  now: string
-): void {
-  const existing = config.installedModules.findIndex((m) => m.name === moduleId);
-  const record = {
-    name: moduleId,
-    version: manifest.version,
-    installedAt: now,
-    files: manifest.files.map((f) => f.dest),
-  };
-  if (existing >= 0) {
-    config.installedModules[existing] = record;
-  } else {
-    config.installedModules.push(record);
-  }
-}
-
-export async function runAdd(options: {
-  moduleName: string;
-  cwd: string;
-  dryRun: boolean;
-  localPath?: string;
-  withSubModules?: string[];
-}): Promise<void> {
-  const { moduleName, cwd, dryRun, localPath, withSubModules = [] } = options;
-
-  // Build full list: main target + --with sub-modules
-  const withIds = withSubModules.map((sub) => `${moduleName}/${sub}`);
-  const allTargets = [moduleName, ...withIds];
-
-  p.intro(`impulse add ${allTargets.join(", ")}${dryRun ? " [dry-run]" : ""}`);
-
-  const config = await readConfig(cwd);
-  if (!config) {
-    p.cancel("No .impulse.json found. Run `impulse init` first.");
-    process.exit(1);
-  }
-
-  const installedNames = new Set(config.installedModules.map((m) => m.name));
-
-  // Check already-installed only for a simple (non-sub-module, no --with) install
-  const { child: mainChild } = parseModuleId(moduleName);
-  if (mainChild === null && withSubModules.length === 0 && installedNames.has(moduleName)) {
-    const existing = config.installedModules.find((m) => m.name === moduleName);
-    p.log.warn(`Module "${moduleName}" is already installed (v${existing?.version ?? "?"}).`);
-    const reinstall = await p.confirm({
-      message: "Reinstall?",
-      initialValue: false,
-    });
-    if (p.isCancel(reinstall) || !reinstall) {
-      p.outro("Cancelled.");
-      return;
-    }
-  }
-
-  // Validate --with sub-module names against the parent manifest's declared sub-modules
-  if (withSubModules.length > 0) {
-    const parentManifest = await fetchModuleManifest(moduleName, localPath).catch(() => null);
-    if (parentManifest) {
-      if (parentManifest.subModules.length === 0) {
-        p.cancel(`"${moduleName}" has no declared sub-modules.`);
-        process.exit(1);
-      }
-      const invalid = withSubModules.filter((sub) => !parentManifest.subModules.includes(sub));
-      if (invalid.length > 0) {
-        p.cancel(
-          `Unknown sub-module(s) for "${moduleName}": ${invalid.join(", ")}.\nAvailable: ${parentManifest.subModules.join(", ")}`
-        );
-        process.exit(1);
-      }
-    }
-  }
-
-  // Resolve dependency order for all targets
-  const s = p.spinner();
-  s.start("Resolving dependencies...");
-
-  const resolved = new Set<string>();
-  const orderedModules: string[] = [];
-
-  try {
-    for (const target of allTargets) {
-      await resolveWithParent(target, localPath, installedNames, resolved, orderedModules);
-    }
-  } catch (err) {
-    s.stop("Dependency resolution failed.");
-    p.cancel(err instanceof Error ? err.message : String(err));
-    process.exit(1);
-  }
-
-  s.stop(`Resolved: ${orderedModules.join(" → ")}`);
-
-  // Fetch all manifests
-  const manifests = new Map<string, ModuleManifest>();
-  for (const id of orderedModules) {
-    manifests.set(id, await fetchModuleManifest(id, localPath));
-  }
-
-  // Collect all npm deps
-  const allDeps = new Set<string>();
-  for (const manifest of manifests.values()) {
-    for (const dep of manifest.dependencies) {
-      allDeps.add(dep);
-    }
-  }
-
-  // Show summary
-  p.log.message("\nSummary of changes:");
-  for (const [id, manifest] of manifests) {
-    p.log.message(`\n  Module: ${id}@${manifest.version}`);
-    for (const file of manifest.files) {
-      p.log.message(`    + ${file.dest}`);
-    }
-    for (const transform of manifest.transforms) {
-      p.log.message(`    ~ ${transform.type} → ${transform.target}`);
-    }
-  }
-
-  // Collect env vars documented across all modules (informational display)
-  const allEnvVars = new Set<string>();
-  for (const manifest of manifests.values()) {
-    for (const envVar of manifest.envVars) {
-      allEnvVars.add(envVar);
-    }
-  }
-
-  if (allDeps.size > 0) {
-    p.log.message(`\n  npm deps: ${[...allDeps].join(", ")}`);
-  }
-
-  if (allEnvVars.size > 0) {
-    p.log.message(`\n  env vars required: ${[...allEnvVars].join(", ")}`);
-  }
-
-  if (!dryRun) {
-    const confirm = await p.confirm({
-      message: "Proceed?",
-      initialValue: true,
-    });
-
-    if (p.isCancel(confirm) || !confirm) {
-      p.outro("Cancelled.");
-      return;
-    }
-  }
-
-  // Split ordered modules into auto-dependencies vs primary targets
-  const primaryTargetSet = new Set(allTargets);
-  const depModules = orderedModules.filter((id) => !primaryTargetSet.has(id) && !installedNames.has(id));
-  const targetModules = orderedModules.filter((id) => primaryTargetSet.has(id));
-
-  // Collect dep postInstall hooks
-  const depPostInstallHooks: Array<{ name: string; hooks: string[] }> = [];
-
-  if (depModules.length > 0) {
-    p.log.step(`Installing module dependencies: ${depModules.join(", ")}`);
-    for (const dep of depModules) {
-      const depManifest = manifests.get(dep);
-      if (!depManifest) continue;
-      await installModule(dep, depManifest, cwd, dryRun, localPath);
-      if (depManifest.postInstall && depManifest.postInstall.length > 0) {
-        depPostInstallHooks.push({ name: dep, hooks: depManifest.postInstall });
-      }
-    }
-  }
-
-  // Install primary targets in resolved order
-  for (const targetId of targetModules) {
-    const targetManifest = manifests.get(targetId);
-    if (!targetManifest) continue;
-    await installModule(targetId, targetManifest, cwd, dryRun, localPath);
-  }
-
-  // Install npm deps so all postInstall hooks have their packages available
-  installNpmDeps([...allDeps], cwd, dryRun);
-
-  // Run post-install hooks for dependency modules
-  if (!dryRun) {
-    for (const { name, hooks } of depPostInstallHooks) {
-      p.log.step(`Running post-install hooks for ${name}...`);
-      for (const hook of hooks) {
-        p.log.message(`  $ ${hook}`);
-        execSync(hook, { cwd, stdio: "inherit" });
-      }
-    }
-  }
-
-  // Run post-install hooks for primary targets
-  if (!dryRun) {
-    for (const targetId of targetModules) {
-      const targetManifest = manifests.get(targetId);
-      if (!targetManifest?.postInstall?.length) continue;
-      p.log.step(`Running post-install hooks for ${targetId}...`);
-      for (const hook of targetManifest.postInstall) {
-        p.log.message(`  $ ${hook}`);
-        execSync(hook, { cwd, stdio: "inherit" });
-      }
-    }
-  }
-
-  // Update .impulse.json
-  if (!dryRun) {
-    const now = new Date().toISOString();
-
-    for (const dep of depModules) {
-      const depManifest = manifests.get(dep);
-      if (depManifest) recordModule(config, dep, depManifest, now);
-    }
-
-    for (const targetId of targetModules) {
-      const targetManifest = manifests.get(targetId);
-      if (targetManifest) recordModule(config, targetId, targetManifest, now);
-    }
-
-    await writeConfig(config, cwd);
-  }
-
-  const label =
-    allTargets.length === 1
-      ? `"${allTargets[0]}"`
-      : allTargets.map((t) => `"${t}"`).join(", ");
-
-  p.outro(
-    dryRun
-      ? "Dry run complete — no files were modified."
-      : `Module(s) ${label} installed successfully!`
-  );
-}