@impulselab/cli 0.1.0 → 0.1.1

package/src/registry/registry.test.ts

@@ -1,181 +0,0 @@
-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,
-  isSubModuleId,
-  fetchModuleManifest,
-  listAvailableModules,
-} from "./index";
-
-let tmpDir: string;
-
-beforeEach(async () => {
-  tmpDir = await mkdtemp(path.join(os.tmpdir(), "impulse-registry-test-"));
-});
-
-afterEach(async () => {
-  await rm(tmpDir, { recursive: true, force: true });
-});
-
-// ---------------------------------------------------------------------------
-// parseModuleId
-// ---------------------------------------------------------------------------
-
-describe("parseModuleId", () => {
-  it("returns parent=name, child=null for a plain module", () => {
-    expect(parseModuleId("attio")).toEqual({ parent: "attio", child: null });
-    expect(parseModuleId("email")).toEqual({ parent: "email", child: null });
-  });
-
-  it("parses parent/child for sub-module syntax", () => {
-    expect(parseModuleId("attio/quote-to-cash")).toEqual({
-      parent: "attio",
-      child: "quote-to-cash",
-    });
-    expect(parseModuleId("attio/gocardless")).toEqual({
-      parent: "attio",
-      child: "gocardless",
-    });
-  });
-
-  it("handles only the first slash (ignores nested slashes)", () => {
-    expect(parseModuleId("a/b/c")).toEqual({ parent: "a", child: "b/c" });
-  });
-});
-
-// ---------------------------------------------------------------------------
-// isSubModuleId
-// ---------------------------------------------------------------------------
-
-describe("isSubModuleId", () => {
-  it("returns false for plain module names", () => {
-    expect(isSubModuleId("attio")).toBe(false);
-    expect(isSubModuleId("email")).toBe(false);
-  });
-
-  it("returns true for slash notation", () => {
-    expect(isSubModuleId("attio/quote-to-cash")).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// fetchModuleManifest — local mode
-// ---------------------------------------------------------------------------
-
-const baseManifest = {
-  name: "attio",
-  version: "1.0.0",
-  description: "Attio module",
-  files: [],
-  transforms: [],
-};
-
-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("fetchModuleManifest (local)", () => {
-  it("resolves a top-level module from localPath", async () => {
-    await writeManifest(path.join(tmpDir, "attio"), baseManifest);
-    const result = await fetchModuleManifest("attio", tmpDir);
-    expect(result.name).toBe("attio");
-    expect(result.version).toBe("1.0.0");
-  });
-
-  it("resolves a sub-module from localPath using slash syntax", async () => {
-    const subManifest = {
-      name: "attio/quote-to-cash",
-      version: "1.0.0",
-      description: "Quote-to-cash sub-module",
-      parentModule: "attio",
-      files: [],
-      transforms: [],
-    };
-    await writeManifest(
-      path.join(tmpDir, "attio", "sub-modules", "quote-to-cash"),
-      subManifest
-    );
-    const result = await fetchModuleManifest("attio/quote-to-cash", tmpDir);
-    expect(result.name).toBe("attio/quote-to-cash");
-    expect(result.parentModule).toBe("attio");
-  });
-
-  it("throws when local module is not found", async () => {
-    await expect(fetchModuleManifest("nonexistent", tmpDir)).rejects.toThrow(
-      "Local module not found"
-    );
-  });
-
-  it("throws when local sub-module is not found", async () => {
-    // parent exists but sub-module does not
-    await writeManifest(path.join(tmpDir, "attio"), baseManifest);
-    await expect(
-      fetchModuleManifest("attio/missing-sub", tmpDir)
-    ).rejects.toThrow("Local module not found");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// listAvailableModules — local mode with sub-modules
-// ---------------------------------------------------------------------------
-
-describe("listAvailableModules (local)", () => {
-  it("lists top-level modules from local directory", async () => {
-    await writeManifest(path.join(tmpDir, "attio"), baseManifest);
-    await writeManifest(path.join(tmpDir, "email"), {
-      ...baseManifest,
-      name: "email",
-      description: "Email module",
-    });
-
-    const result = await listAvailableModules(tmpDir);
-    const names = result.map((m) => m.name);
-    expect(names).toContain("attio");
-    expect(names).toContain("email");
-  });
-
-  it("includes subModules array when sub-modules directory exists", async () => {
-    await writeManifest(path.join(tmpDir, "attio"), baseManifest);
-    await writeManifest(
-      path.join(tmpDir, "attio", "sub-modules", "quote-to-cash"),
-      { ...baseManifest, name: "attio/quote-to-cash", parentModule: "attio" }
-    );
-    await writeManifest(
-      path.join(tmpDir, "attio", "sub-modules", "gocardless"),
-      { ...baseManifest, name: "attio/gocardless", parentModule: "attio" }
-    );
-
-    const result = await listAvailableModules(tmpDir);
-    const attio = result.find((m) => m.name === "attio");
-    expect(attio?.subModules).toBeDefined();
-    expect(attio?.subModules).toContain("quote-to-cash");
-    expect(attio?.subModules).toContain("gocardless");
-  });
-
-  it("returns undefined subModules when no sub-modules directory", async () => {
-    await writeManifest(path.join(tmpDir, "email"), {
-      ...baseManifest,
-      name: "email",
-    });
-
-    const result = await listAvailableModules(tmpDir);
-    const email = result.find((m) => m.name === "email");
-    expect(email?.subModules).toBeUndefined();
-  });
-
-  it("skips directories without module.json", async () => {
-    // Create a dir without module.json
-    await mkdir(path.join(tmpDir, "not-a-module"), { recursive: true });
-    await writeManifest(path.join(tmpDir, "email"), {
-      ...baseManifest,
-      name: "email",
-    });
-
-    const result = await listAvailableModules(tmpDir);
-    expect(result.map((m) => m.name)).not.toContain("not-a-module");
-  });
-});

package/src/schemas/impulse-config.ts

@@ -1,21 +0,0 @@
-import { z } from "zod";
-
-export const ImpulseConfigSchema = z.object({
-  version: z.string().default("1"),
-  projectName: z.string(),
-  srcPath: z.string().default("src"),
-  dbPath: z.string().default("src/server/db"),
-  routesPath: z.string().default("src/server/api"),
-  installedModules: z
-    .array(
-      z.object({
-        name: z.string(),
-        version: z.string(),
-        installedAt: z.string(),
-        files: z.array(z.string()),
-      })
-    )
-    .default([]),
-});
-
-export type ImpulseConfig = z.infer<typeof ImpulseConfigSchema>;

package/src/schemas/index.ts

@@ -1,9 +0,0 @@
-export { ModuleFileSchema } from "./module-file";
-export type { ModuleFile } from "./module-file";
-export { ModuleDependencySchema } from "./module-dependency";
-export { ModuleTransformSchema } from "./module-transform";
-export type { ModuleTransform } from "./module-transform";
-export { ModuleManifestSchema } from "./module-manifest";
-export type { ModuleManifest } from "./module-manifest";
-export { ImpulseConfigSchema } from "./impulse-config";
-export type { ImpulseConfig } from "./impulse-config";

package/src/schemas/module-dependency.ts

@@ -1,3 +0,0 @@
-import { z } from "zod";
-
-export const ModuleDependencySchema = z.string();

package/src/schemas/module-file.ts

@@ -1,8 +0,0 @@
-import { z } from "zod";
-
-export const ModuleFileSchema = z.object({
-  src: z.string(),
-  dest: z.string(),
-});
-
-export type ModuleFile = z.infer<typeof ModuleFileSchema>;

package/src/schemas/module-manifest.ts

@@ -1,23 +0,0 @@
-import { z } from "zod";
-import { ModuleFileSchema } from "./module-file";
-import { ModuleDependencySchema } from "./module-dependency";
-import { ModuleTransformSchema } from "./module-transform";
-
-export const ModuleManifestSchema = z.object({
-  name: z.string(),
-  version: z.string(),
-  description: z.string(),
-  /** If set, this module is a sub-module of the named parent (e.g. "attio"). */
-  parentModule: z.string().optional(),
-  /** Names of sub-modules available under this parent module (e.g. ["quote-to-cash", "gocardless"]). */
-  subModules: z.array(z.string()).default([]),
-  dependencies: z.array(ModuleDependencySchema).default([]),
-  moduleDependencies: z.array(z.string()).default([]),
-  files: z.array(ModuleFileSchema).default([]),
-  transforms: z.array(ModuleTransformSchema).default([]),
-  /** Documentation metadata listing env vars this module requires (displayed in install summary). */
-  envVars: z.array(z.string()).default([]),
-  postInstall: z.array(z.string()).optional(),
-});
-
-export type ModuleManifest = z.infer<typeof ModuleManifestSchema>;

package/src/schemas/module-transform.ts

@@ -1,15 +0,0 @@
-import { z } from "zod";
-
-export const ModuleTransformSchema = z.object({
-  type: z.enum([
-    "append-export",
-    "register-route",
-    "add-nav-item",
-    "merge-schema",
-    "add-env",
-  ]),
-  target: z.string(),
-  value: z.string(),
-});
-
-export type ModuleTransform = z.infer<typeof ModuleTransformSchema>;

package/src/transforms/add-env.ts

@@ -1,53 +0,0 @@
-import fsExtra from "fs-extra";
-const { readFile, outputFile, pathExists } = fsExtra;
-import path from "path";
-import * as p from "@clack/prompts";
-
-/**
- * Prompts for an env var value and appends to .env if not already present.
- * target: path to .env file (e.g. ".env")
- * value: the env var name (e.g. "AUTH_SECRET")
- */
-export async function addEnv(
-  target: string,
-  value: string,
-  cwd: string,
-  dryRun: boolean
-): Promise<void> {
-  const file = path.join(cwd, target);
-  let content = "";
-
-  if (await pathExists(file)) {
-    content = await readFile(file, "utf-8");
-    // Check if key already set — escape value to avoid regex injection
-    const escaped = value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const keyPattern = new RegExp(`^${escaped}=`, "m");
-    if (keyPattern.test(content)) return;
-  }
-
-  let envValue = "";
-  if (!dryRun) {
-    const answer = await p.text({
-      message: `Enter value for ${value} (leave blank to skip):`,
-      placeholder: "",
-    });
-
-    if (p.isCancel(answer)) {
-      p.log.warn(`Skipped env var: ${value}`);
-      return;
-    }
-
-    envValue = String(answer);
-  }
-
-  const line = `${value}=${envValue}`;
-
-  if (!dryRun) {
-    const newContent = content
-      ? content.endsWith("\n")
-        ? `${content}${line}\n`
-        : `${content}\n${line}\n`
-      : `${line}\n`;
-    await outputFile(file, newContent, "utf-8");
-  }
-}

package/src/transforms/add-nav-item.test.ts

@@ -1,125 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { mkdtemp, rm } from "fs/promises";
-import { outputFile, readFile } from "fs-extra";
-import path from "path";
-import os from "os";
-import { addNavItem } from "./add-nav-item";
-
-let tmpDir: string;
-
-beforeEach(async () => {
-  tmpDir = await mkdtemp(path.join(os.tmpdir(), "impulse-nav-test-"));
-});
-
-afterEach(async () => {
-  await rm(tmpDir, { recursive: true, force: true });
-});
-
-describe("addNavItem", () => {
-  it("inserts item into a flat nav array", async () => {
-    const navFile = path.join(tmpDir, "src/config/nav.ts");
-    await outputFile(
-      navFile,
-      `export const navItems = [\n  { title: "Home", href: "/" },\n];\n`
-    );
-
-    await addNavItem(
-      "src/config/nav.ts",
-      '{ title: "Auth", href: "/auth" }',
-      tmpDir,
-      false
-    );
-
-    const result = await readFile(navFile, "utf-8");
-    expect(result).toContain('{ title: "Auth", href: "/auth" }');
-    expect(result).toContain('{ title: "Home", href: "/" }');
-    // insertion uses trailing newline — closing ] must be on its own line
-    expect(result).toMatch(/\},\n\]/);
-  });
-
-  it("inserts item into a typed array declaration (const navItems: NavItem[] = [...])", async () => {
-    const navFile = path.join(tmpDir, "src/config/nav.ts");
-    await outputFile(
-      navFile,
-      `export const navItems: NavItem[] = [\n  { title: "Home", href: "/" },\n];\n`
-    );
-
-    await addNavItem(
-      "src/config/nav.ts",
-      '{ title: "Auth", href: "/auth" }',
-      tmpDir,
-      false
-    );
-
-    const result = await readFile(navFile, "utf-8");
-    expect(result).toContain('{ title: "Auth", href: "/auth" }');
-  });
-
-  it("inserts item into a nav array with nested arrays (nested subnav)", async () => {
-    const navFile = path.join(tmpDir, "src/config/nav.ts");
-    await outputFile(
-      navFile,
-      `export const navItems = [\n  {\n    title: "Settings",\n    href: "/settings",\n    children: [\n      { title: "Profile", href: "/settings/profile" },\n    ],\n  },\n];\n`
-    );
-
-    await addNavItem(
-      "src/config/nav.ts",
-      '{ title: "Auth", href: "/auth" }',
-      tmpDir,
-      false
-    );
-
-    const result = await readFile(navFile, "utf-8");
-    // Item should be appended before the outer closing bracket
-    expect(result).toContain('{ title: "Auth", href: "/auth" }');
-    // Nested structure must be preserved
-    expect(result).toContain("children:");
-  });
-
-  it("does not insert duplicate items", async () => {
-    const navFile = path.join(tmpDir, "src/config/nav.ts");
-    const item = '{ title: "Auth", href: "/auth" }';
-    await outputFile(navFile, `export const navItems = [\n  ${item},\n];\n`);
-
-    await addNavItem("src/config/nav.ts", item, tmpDir, false);
-
-    const result = await readFile(navFile, "utf-8");
-    expect(result.split(item).length - 1).toBe(1);
-  });
-
-  it("does not write file in dry-run mode", async () => {
-    const navFile = path.join(tmpDir, "src/config/nav.ts");
-    const original = `export const navItems = [\n  { title: "Home", href: "/" },\n];\n`;
-    await outputFile(navFile, original);
-
-    await addNavItem(
-      "src/config/nav.ts",
-      '{ title: "Auth", href: "/auth" }',
-      tmpDir,
-      true
-    );
-
-    const result = await readFile(navFile, "utf-8");
-    expect(result).toBe(original);
-  });
-
-  it("throws if file not found", async () => {
-    await expect(
-      addNavItem("nonexistent/nav.ts", '{ title: "X" }', tmpDir, false)
-    ).rejects.toThrow("target file not found");
-  });
-
-  it("throws if no nav array can be located", async () => {
-    const navFile = path.join(tmpDir, "src/config/nav.ts");
-    await outputFile(navFile, `export const foo = "bar";\n`);
-
-    await expect(
-      addNavItem(
-        "src/config/nav.ts",
-        '{ title: "Auth", href: "/auth" }',
-        tmpDir,
-        false
-      )
-    ).rejects.toThrow("could not locate nav array");
-  });
-});

package/src/transforms/add-nav-item.ts

@@ -1,70 +0,0 @@
-import fsExtra from "fs-extra";
-const { readFile, outputFile, pathExists } = fsExtra;
-import path from "path";
-
-/**
- * Adds a navigation item to the sidebar config file.
- * target: path to the nav config file (e.g. "src/config/nav.ts")
- * value: the nav item JSON string to inject
- *        (e.g. '{ title: "Auth", href: "/auth", icon: "lock" }')
- */
-export async function addNavItem(
-  target: string,
-  value: string,
-  cwd: string,
-  dryRun: boolean
-): Promise<void> {
-  const file = path.join(cwd, target);
-
-  if (!(await pathExists(file))) {
-    throw new Error(
-      `add-nav-item: target file not found: ${target}`
-    );
-  }
-
-  const content = await readFile(file, "utf-8");
-  if (content.includes(value)) return;
-
-  // Find the opening bracket of the navItems array using a pattern match,
-  // then walk brackets to find the matching close — handles nested arrays.
-  // The type annotation group handles typed declarations: `const navItems: NavItem[] = [`
-  const openPattern = /(?:const\s+\w+(?:\s*:\s*[\w<>\[\], ]+)?\s*=\s*\[|items\s*:\s*\[)/;
-  const openMatch = openPattern.exec(content);
-
-  if (!openMatch) {
-    throw new Error(
-      `add-nav-item: could not locate nav array in ${target}. Add "${value}" manually.`
-    );
-  }
-
-  // Position of the '[' that opens the array
-  const bracketStart = openMatch.index + openMatch[0].length - 1;
-
-  // Walk forward counting brackets to find the matching ']'
-  let depth = 0;
-  let insertPos = -1;
-  for (let i = bracketStart; i < content.length; i++) {
-    if (content[i] === "[") depth++;
-    else if (content[i] === "]") {
-      depth--;
-      if (depth === 0) {
-        insertPos = i;
-        break;
-      }
-    }
-  }
-
-  if (insertPos === -1) {
-    throw new Error(
-      `add-nav-item: could not find closing bracket for nav array in ${target}. Add "${value}" manually.`
-    );
-  }
-
-  if (!dryRun) {
-    const newContent =
-      content.slice(0, insertPos) +
-      `  ${value},\n` +
-      content.slice(insertPos);
-    await outputFile(file, newContent, "utf-8");
-  }
-}

package/src/transforms/append-export.test.ts

@@ -1,50 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { mkdtemp, rm } from "fs/promises";
-import { outputFile, readFile } from "fs-extra";
-import path from "path";
-import os from "os";
-import { appendExport } from "./append-export";
-
-let tmpDir: string;
-
-beforeEach(async () => {
-  tmpDir = await mkdtemp(path.join(os.tmpdir(), "impulse-test-"));
-});
-
-afterEach(async () => {
-  await rm(tmpDir, { recursive: true, force: true });
-});
-
-describe("appendExport", () => {
-  it("creates the file if it does not exist", async () => {
-    await appendExport("src/index.ts", "export * from './auth'", tmpDir, false);
-    const content = await readFile(path.join(tmpDir, "src/index.ts"), "utf-8");
-    expect(content).toBe("export * from './auth'\n");
-  });
-
-  it("appends to existing file", async () => {
-    await outputFile(
-      path.join(tmpDir, "src/index.ts"),
-      "export * from './existing'\n"
-    );
-    await appendExport("src/index.ts", "export * from './auth'", tmpDir, false);
-    const content = await readFile(path.join(tmpDir, "src/index.ts"), "utf-8");
-    expect(content).toBe("export * from './existing'\nexport * from './auth'\n");
-  });
-
-  it("does not duplicate if already present", async () => {
-    await outputFile(
-      path.join(tmpDir, "src/index.ts"),
-      "export * from './auth'\n"
-    );
-    await appendExport("src/index.ts", "export * from './auth'", tmpDir, false);
-    const content = await readFile(path.join(tmpDir, "src/index.ts"), "utf-8");
-    expect(content).toBe("export * from './auth'\n");
-  });
-
-  it("does not write in dry-run mode", async () => {
-    await appendExport("src/index.ts", "export * from './auth'", tmpDir, true);
-    const { pathExists } = await import("fs-extra");
-    expect(await pathExists(path.join(tmpDir, "src/index.ts"))).toBe(false);
-  });
-});

package/src/transforms/append-export.ts

@@ -1,34 +0,0 @@
-import fsExtra from "fs-extra";
-const { readFile, outputFile, pathExists } = fsExtra;
-import path from "path";
-
-/**
- * Appends an export line to a barrel file if not already present.
- * target: relative path to the barrel file (e.g. "src/server/api/index.ts")
- * value: the export line to append (e.g. "export * from './auth'")
- */
-export async function appendExport(
-  target: string,
-  value: string,
-  cwd: string,
-  dryRun: boolean
-): Promise<void> {
-  const file = path.join(cwd, target);
-
-  if (!(await pathExists(file))) {
-    if (!dryRun) {
-      await outputFile(file, `${value}\n`, "utf-8");
-    }
-    return;
-  }
-
-  const content = await readFile(file, "utf-8");
-  if (content.includes(value)) return; // already present
-
-  if (!dryRun) {
-    const newContent = content.endsWith("\n")
-      ? `${content}${value}\n`
-      : `${content}\n${value}\n`;
-    await outputFile(file, newContent, "utf-8");
-  }
-}

package/src/transforms/index.ts

@@ -1,32 +0,0 @@
-import { appendExport } from "./append-export";
-import { registerRoute } from "./register-route";
-import { addNavItem } from "./add-nav-item";
-import { mergeSchema } from "./merge-schema";
-import { addEnv } from "./add-env";
-import type { ModuleTransform } from "../types";
-
-export async function runTransform(
-  transform: ModuleTransform,
-  cwd: string,
-  dryRun: boolean
-): Promise<void> {
-  switch (transform.type) {
-    case "append-export":
-      await appendExport(transform.target, transform.value, cwd, dryRun);
-      break;
-    case "register-route":
-      await registerRoute(transform.target, transform.value, cwd, dryRun);
-      break;
-    case "add-nav-item":
-      await addNavItem(transform.target, transform.value, cwd, dryRun);
-      break;
-    case "merge-schema":
-      await mergeSchema(transform.target, transform.value, cwd, dryRun);
-      break;
-    case "add-env":
-      await addEnv(transform.target, transform.value, cwd, dryRun);
-      break;
-  }
-}
-
-export { appendExport, registerRoute, addNavItem, mergeSchema, addEnv };