@impulselab/cli 0.1.0 → 0.1.2

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!`
-  );
-}

package/src/commands/init.ts

@@ -1,114 +0,0 @@
-import fsExtra from "fs-extra";
-const { readJson, pathExists } = fsExtra;
-import path from "path";
-import * as p from "@clack/prompts";
-import { writeConfig, hasConfig } from "../config/index";
-import type { ImpulseConfig } from "../types";
-
-const ULTIMATE_TEMPLATE_MARKERS = [
-  "@impulselab/ultimate-template",
-  "ultimate-template",
-];
-
-async function detectProjectName(cwd: string): Promise<string> {
-  const pkgPath = path.join(cwd, "package.json");
-  if (await pathExists(pkgPath)) {
-    const pkg: unknown = await readJson(pkgPath);
-    if (
-      pkg !== null &&
-      typeof pkg === "object" &&
-      "name" in pkg &&
-      typeof (pkg as Record<string, unknown>).name === "string"
-    ) {
-      return (pkg as { name: string }).name;
-    }
-  }
-  return path.basename(cwd);
-}
-
-async function isUltimateTemplate(cwd: string): Promise<boolean> {
-  const pkgPath = path.join(cwd, "package.json");
-  if (!(await pathExists(pkgPath))) return false;
-
-  const raw: unknown = await readJson(pkgPath);
-  if (!raw || typeof raw !== "object") return false;
-
-  const pkg = raw as Record<string, unknown>;
-  const name = typeof pkg["name"] === "string" ? pkg["name"] : "";
-  const keywords = Array.isArray(pkg["keywords"]) ? pkg["keywords"] : [];
-
-  const nameMatches = ULTIMATE_TEMPLATE_MARKERS.some((m) => name.includes(m));
-  const keywordMatches = ULTIMATE_TEMPLATE_MARKERS.some((m) =>
-    keywords.includes(m)
-  );
-
-  return nameMatches || keywordMatches;
-}
-
-export async function runInit(options: {
-  cwd: string;
-  force: boolean;
-}): Promise<void> {
-  const { cwd, force } = options;
-
-  p.intro("impulse init");
-
-  // Check if already initialized
-  if (!force && (await hasConfig(cwd))) {
-    p.log.warn(
-      ".impulse.json already exists. Run with --force to reinitialize."
-    );
-    p.outro("Already initialized.");
-    return;
-  }
-
-  // Validate project
-  const s = p.spinner();
-  s.start("Checking project...");
-
-  const pkgExists = await pathExists(path.join(cwd, "package.json"));
-  if (!pkgExists) {
-    s.stop("Not a Node.js project.");
-    p.cancel(
-      "No package.json found. Run impulse init from the root of your project."
-    );
-    process.exit(1);
-  }
-
-  const isUT = await isUltimateTemplate(cwd);
-  s.stop(isUT ? "Ultimate Template project detected." : "Project detected.");
-
-  if (!isUT) {
-    const proceed = await p.confirm({
-      message:
-        "This project does not appear to be an ImpulseLab Ultimate Template. Continue anyway?",
-      initialValue: false,
-    });
-
-    if (p.isCancel(proceed) || !proceed) {
-      p.cancel("Initialization cancelled.");
-      process.exit(0);
-    }
-  }
-
-  // Detect project structure
-  const projectName = await detectProjectName(cwd);
-
-  const srcExists = await pathExists(path.join(cwd, "src"));
-  const srcPath = srcExists ? "src" : ".";
-
-  const config: ImpulseConfig = {
-    version: "1",
-    projectName,
-    srcPath,
-    dbPath: srcExists ? `${srcPath}/server/db` : "server/db",
-    routesPath: srcExists ? `${srcPath}/server/api` : "server/api",
-    installedModules: [],
-  };
-
-  await writeConfig(config, cwd);
-
-  p.outro(
-    `.impulse.json created for project "${projectName}". Run \`impulse list\` to see available modules.`
-  );
-}

package/src/commands/list.ts

@@ -1,79 +0,0 @@
-import * as p from "@clack/prompts";
-import { readConfig } from "../config/index";
-import { listAvailableModules } from "../registry/index";
-
-export async function runList(options: {
-  cwd: string;
-  localPath?: string;
-}): Promise<void> {
-  const { cwd, localPath } = options;
-
-  p.intro("impulse list");
-
-  const config = await readConfig(cwd);
-  const installedNames = new Set(
-    config?.installedModules.map((m) => m.name) ?? []
-  );
-
-  const s = p.spinner();
-  s.start("Fetching available modules...");
-
-  let available: { name: string; description?: string; subModules?: string[] }[];
-  try {
-    available = await listAvailableModules(localPath);
-  } catch (err) {
-    s.stop("Failed to fetch module list.");
-    p.cancel(err instanceof Error ? err.message : String(err));
-    process.exit(1);
-  }
-
-  s.stop(`Found ${available.length} module(s).`);
-
-  if (available.length === 0) {
-    p.log.message("No modules available yet.");
-    p.outro("Done.");
-    return;
-  }
-
-  p.log.message("\nAvailable modules:\n");
-
-  for (const mod of available) {
-    const installed = installedNames.has(mod.name);
-    const installedInfo = installed
-      ? config?.installedModules.find((m) => m.name === mod.name)
-      : null;
-
-    const status = installed
-      ? `[installed v${installedInfo?.version ?? "?"}]`
-      : "[available]";
-
-    const desc = mod.description ? ` — ${mod.description}` : "";
-    p.log.message(`  ${installed ? "✓" : "○"} ${mod.name} ${status}${desc}`);
-
-    // Show sub-modules nested under their parent
-    if (mod.subModules && mod.subModules.length > 0) {
-      const last = mod.subModules.length - 1;
-      mod.subModules.forEach((sub, i) => {
-        const subId = `${mod.name}/${sub}`;
-        const subInstalled = installedNames.has(subId);
-        const subInfo = subInstalled
-          ? config?.installedModules.find((m) => m.name === subId)
-          : null;
-        const subStatus = subInstalled
-          ? `[installed v${subInfo?.version ?? "?"}]`
-          : "[not installed]";
-        const connector = i === last ? "└─" : "├─";
-        p.log.message(`    ${connector} ${sub} ${subStatus}`);
-      });
-    }
-  }
-
-  p.log.message(
-    `\nRun \`impulse add <module>\` to install a module.`
-  );
-  p.log.message(
-    `Run \`impulse add <parent>/<sub>\` or \`impulse add <parent> --with <sub1>,<sub2>\` for sub-modules.`
-  );
-
-  p.outro("Done.");
-}

package/src/config/config-path.ts

@@ -1,7 +0,0 @@
-import path from "path";
-
-const CONFIG_FILE = ".impulse.json";
-
-export function configPath(cwd: string = process.cwd()): string {
-  return path.join(cwd, CONFIG_FILE);
-}

package/src/config/has-config.ts

@@ -1,9 +0,0 @@
-import fsExtra from "fs-extra";
-const { pathExists } = fsExtra;
-import { configPath } from "./config-path";
-
-export async function hasConfig(
-  cwd: string = process.cwd()
-): Promise<boolean> {
-  return pathExists(configPath(cwd));
-}

package/src/config/index.ts

@@ -1,4 +0,0 @@
-export { configPath } from "./config-path";
-export { readConfig } from "./read-config";
-export { writeConfig } from "./write-config";
-export { hasConfig } from "./has-config";

package/src/config/read-config.ts

@@ -1,20 +0,0 @@
-import fsExtra from "fs-extra";
-const { readJson, pathExists } = fsExtra;
-import { ImpulseConfigSchema } from "../schemas/impulse-config";
-import type { ImpulseConfig } from "../schemas/impulse-config";
-import { configPath } from "./config-path";
-
-export async function readConfig(
-  cwd: string = process.cwd()
-): Promise<ImpulseConfig | null> {
-  const file = configPath(cwd);
-  if (!(await pathExists(file))) return null;
-  const raw = await readJson(file);
-  const parsed = ImpulseConfigSchema.safeParse(raw);
-  if (!parsed.success) {
-    throw new Error(
-      `Invalid .impulse.json: ${parsed.error.message}`
-    );
-  }
-  return parsed.data;
-}

package/src/config/write-config.ts

@@ -1,11 +0,0 @@
-import fsExtra from "fs-extra";
-const { writeJson } = fsExtra;
-import type { ImpulseConfig } from "../schemas/impulse-config";
-import { configPath } from "./config-path";
-
-export async function writeConfig(
-  config: ImpulseConfig,
-  cwd: string = process.cwd()
-): Promise<void> {
-  await writeJson(configPath(cwd), config, { spaces: 2 });
-}

package/src/config.test.ts

@@ -1,64 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { mkdtemp, rm } from "fs/promises";
-import path from "path";
-import os from "os";
-import { readConfig, writeConfig, hasConfig } from "./config/index";
-import type { ImpulseConfig } from "./types";
-
-let tmpDir: string;
-
-beforeEach(async () => {
-  tmpDir = await mkdtemp(path.join(os.tmpdir(), "impulse-config-test-"));
-});
-
-afterEach(async () => {
-  await rm(tmpDir, { recursive: true, force: true });
-});
-
-const sampleConfig: ImpulseConfig = {
-  version: "1",
-  projectName: "my-project",
-  srcPath: "src",
-  dbPath: "src/server/db",
-  routesPath: "src/server/api",
-  installedModules: [],
-};
-
-describe("config", () => {
-  it("returns null if no config file", async () => {
-    expect(await readConfig(tmpDir)).toBeNull();
-  });
-
-  it("writes and reads config", async () => {
-    await writeConfig(sampleConfig, tmpDir);
-    const config = await readConfig(tmpDir);
-    expect(config).toEqual(sampleConfig);
-  });
-
-  it("hasConfig returns false before init", async () => {
-    expect(await hasConfig(tmpDir)).toBe(false);
-  });
-
-  it("hasConfig returns true after write", async () => {
-    await writeConfig(sampleConfig, tmpDir);
-    expect(await hasConfig(tmpDir)).toBe(true);
-  });
-
-  it("tracks installed modules", async () => {
-    const config: ImpulseConfig = {
-      ...sampleConfig,
-      installedModules: [
-        {
-          name: "auth",
-          version: "1.0.0",
-          installedAt: "2026-01-01T00:00:00.000Z",
-          files: ["src/server/api/auth.ts"],
-        },
-      ],
-    };
-    await writeConfig(config, tmpDir);
-    const read = await readConfig(tmpDir);
-    expect(read?.installedModules).toHaveLength(1);
-    expect(read?.installedModules[0]?.name).toBe("auth");
-  });
-});