regpick 0.2.3

package/src/domain/__tests__/selection.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, it } from "vitest";
+
+import type { CommandContext, RegistryItem } from "../../types.js";
+import type { RuntimePorts } from "../../shell/runtime/ports.js";
+import { filterItemsByQuery, parseSelectedNames, selectItemsFromFlags } from "../selection.js";
+
+const items: RegistryItem[] = [
+  {
+    name: "check",
+    title: "Check",
+    description: "Check icon",
+    type: "registry:icon",
+    dependencies: [],
+    devDependencies: [],
+    registryDependencies: [],
+    files: [{ type: "registry:file", path: "icons/check.tsx" }],
+    sourceMeta: { type: "directory", baseDir: "/registry" },
+  },
+  {
+    name: "calendar",
+    title: "Calendar",
+    description: "Calendar icon",
+    type: "registry:icon",
+    dependencies: [],
+    devDependencies: [],
+    registryDependencies: [],
+    files: [{ type: "registry:file", path: "icons/calendar.tsx" }],
+    sourceMeta: { type: "directory", baseDir: "/registry" },
+  },
+];
+
+function context(flags: CommandContext["args"]["flags"]): CommandContext {
+  return {
+    cwd: "/tmp/project",
+    args: { flags, positionals: ["add"] },
+    runtime: {} as RuntimePorts,
+  };
+}
+
+describe("selection core", () => {
+  it("parses --select values", () => {
+    expect(parseSelectedNames("check,calendar")).toEqual(["check", "calendar"]);
+  });
+
+  it("filters by query against name/title/description", () => {
+    expect(filterItemsByQuery(items, "cal")).toHaveLength(1);
+    expect(filterItemsByQuery(items, "icon")).toHaveLength(2);
+  });
+
+  it("selects all when --all is set", () => {
+    expect(selectItemsFromFlags(items, context({ all: true }))).toEqual({ ok: true, value: items });
+  });
+
+  it("selects explicit items when --select is set", () => {
+    const result = selectItemsFromFlags(items, context({ select: "check" }));
+    expect(result.ok && result.value?.map((item) => item.name)).toEqual(["check"]);
+  });
+});

package/src/domain/addPlan.ts

@@ -0,0 +1,51 @@
+import type { InstallPlan, PlannedWrite, RegpickConfig, RegistryItem } from "../types.js";
+import { resolveOutputPathFromPolicy } from "./pathPolicy.js";
+import { err, ok, type Result } from "../core/result.js";
+import type { AppError } from "../core/errors.js";
+
+function unique(values: string[]): string[] {
+  return [...new Set(values.filter(Boolean))];
+}
+
+function buildDependencyPlan(selectedItems: RegistryItem[]): InstallPlan["dependencyPlan"] {
+  return {
+    dependencies: unique(selectedItems.flatMap((item) => item.dependencies || [])),
+    devDependencies: unique(selectedItems.flatMap((item) => item.devDependencies || [])),
+  };
+}
+
+export function buildInstallPlan(
+  selectedItems: RegistryItem[],
+  cwd: string,
+  config: RegpickConfig,
+  existingTargets: Set<string> = new Set(),
+): Result<InstallPlan, AppError> {
+  const plannedWrites: PlannedWrite[] = [];
+  const conflicts: PlannedWrite[] = [];
+
+  for (const item of selectedItems) {
+    for (const file of item.files) {
+      const outputRes = resolveOutputPathFromPolicy(item, file, cwd, config);
+      if (!outputRes.ok) return outputRes;
+      
+      const { absoluteTarget, relativeTarget } = outputRes.value;
+      const planned: PlannedWrite = {
+        itemName: item.name,
+        sourceFile: file,
+        absoluteTarget,
+        relativeTarget,
+      };
+      plannedWrites.push(planned);
+      if (existingTargets.has(absoluteTarget)) {
+        conflicts.push(planned);
+      }
+    }
+  }
+
+  return ok({
+    selectedItems,
+    plannedWrites,
+    dependencyPlan: buildDependencyPlan(selectedItems),
+    conflicts,
+  });
+}

package/src/domain/aliasCore.ts

@@ -0,0 +1,13 @@
+import type { RegpickConfig } from "../types.js";
+
+export function applyAliases(content: string, config: RegpickConfig): string {
+  let result = content;
+  for (const [oldAlias, newAlias] of Object.entries(config.aliases || {})) {
+    const regex = new RegExp(`from ["']${oldAlias}(.*?)["']`, "g");
+    result = result.replace(regex, `from "${newAlias}$1"`);
+    // Also handle dynamic imports
+    const dynRegex = new RegExp(`import\\(["']${oldAlias}(.*?)["']\\)`, "g");
+    result = result.replace(dynRegex, `import("${newAlias}$1")`);
+  }
+  return result;
+}

package/src/domain/initCore.ts

@@ -0,0 +1,15 @@
+type InitDecision = "created" | "ask-overwrite" | "overwrite" | "keep" | "cancelled";
+
+export function decideInitAfterFirstWrite(firstWriteSucceeded: boolean): InitDecision {
+  return firstWriteSucceeded ? "created" : "ask-overwrite";
+}
+
+export function decideInitAfterOverwritePrompt(
+  isPromptCancelled: boolean,
+  shouldOverwrite: boolean,
+): InitDecision {
+  if (isPromptCancelled) {
+    return "cancelled";
+  }
+  return shouldOverwrite ? "overwrite" : "keep";
+}

package/src/domain/listCore.ts

@@ -0,0 +1,34 @@
+import type { RegistryItem } from "../types.js";
+
+type Registries = Record<string, string>;
+
+export function resolveRegistrySourceFromAliases(
+  input: string | undefined,
+  registries: Registries,
+): string | null {
+  if (!input) {
+    return null;
+  }
+
+  return registries[input] ? String(registries[input]) : input;
+}
+
+export function resolveListSourceDecision(
+  providedInput: string | undefined,
+  registries: Registries,
+): { source: string | null; requiresPrompt: boolean } {
+  const fromInput = resolveRegistrySourceFromAliases(providedInput, registries);
+  if (fromInput) {
+    return { source: fromInput, requiresPrompt: false };
+  }
+
+  const defaultAlias = Object.keys(registries)[0];
+  if (defaultAlias) {
+    return {
+      source: resolveRegistrySourceFromAliases(defaultAlias, registries),
+      requiresPrompt: false,
+    };
+  }
+
+  return { source: null, requiresPrompt: true };
+}

package/src/domain/packCore.ts

@@ -0,0 +1,44 @@
+export function extractDependencies(content: string): string[] {
+  const importRegex = /import\s+[\s\S]*?from\s+["']([^"']+)["']/g;
+  const dynamicImportRegex = /import\(["']([^"']+)["']\)/g;
+  
+  const deps = new Set<string>();
+  
+  let match;
+  while ((match = importRegex.exec(content)) !== null) {
+    const specifier = match[1];
+    if (
+      !specifier.startsWith(".") &&
+      !specifier.startsWith("/") &&
+      !specifier.startsWith("~") &&
+      !specifier.startsWith("@/") &&
+      !specifier.startsWith("@\\")
+    ) {
+      const parts = specifier.split("/");
+      if (specifier.startsWith("@") && parts.length > 1) {
+        deps.add(`${parts[0]}/${parts[1]}`);
+      } else {
+        deps.add(parts[0]);
+      }
+    }
+  }
+  while ((match = dynamicImportRegex.exec(content)) !== null) {
+    const specifier = match[1];
+    if (
+      !specifier.startsWith(".") &&
+      !specifier.startsWith("/") &&
+      !specifier.startsWith("~") &&
+      !specifier.startsWith("@/") &&
+      !specifier.startsWith("@\\")
+    ) {
+      const parts = specifier.split("/");
+      if (specifier.startsWith("@") && parts.length > 1) {
+        deps.add(`${parts[0]}/${parts[1]}`);
+      } else {
+        deps.add(parts[0]);
+      }
+    }
+  }
+
+  return Array.from(deps);
+}

package/src/domain/pathPolicy.ts

@@ -0,0 +1,61 @@
+import path from "node:path";
+
+import type { RegpickConfig, RegistryFile, RegistryItem } from "../types.js";
+
+import { appError, type AppError } from "../core/errors.js";
+import { err, ok, type Result } from "../core/result.js";
+
+function normalizeSlashes(relativePath: string): string {
+  return relativePath.replace(/\\/g, "/");
+}
+
+function assertInsideProject(
+  projectRoot: string,
+  outputPath: string,
+  allowOutsideProject: boolean,
+): Result<void, AppError> {
+  const projectRootWithSep = `${path.resolve(projectRoot)}${path.sep}`;
+    const resolvedOutput = path.resolve(outputPath);
+  if (allowOutsideProject) {
+    return ok(undefined);
+  }
+  if (
+    resolvedOutput !== path.resolve(projectRoot) &&
+    !resolvedOutput.startsWith(projectRootWithSep)
+  ) {
+    return err(appError("ValidationError", `Refusing to write outside project: ${resolvedOutput}`));
+  }
+  return ok(undefined);
+}
+
+export function resolveOutputPathFromPolicy(
+  item: RegistryItem,
+  file: RegistryFile,
+  cwd: string,
+  config: RegpickConfig,
+): Result<{ absoluteTarget: string; relativeTarget: string }, AppError> {
+  const typeKey = file.type || item.type || "registry:file";
+  const mappedBase = config.targetsByType?.[typeKey];
+  const preferManifestTarget = config.preferManifestTarget !== false;
+  const fallbackFileName = path.basename(file.path || `${item.name}.txt`);
+
+  let relativeTarget: string;
+  if (preferManifestTarget && file.target) {
+    relativeTarget = file.target;
+  } else if (mappedBase) {
+    relativeTarget = path.join(mappedBase, fallbackFileName);
+  } else if (file.target) {
+    relativeTarget = file.target;
+  } else {
+    relativeTarget = path.join("src", fallbackFileName);
+  }
+
+  const absoluteTarget = path.resolve(cwd, relativeTarget);
+  const assertRes = assertInsideProject(cwd, absoluteTarget, Boolean(config.allowOutsideProject));
+  if (!assertRes.ok) return assertRes;
+  
+  return ok({
+    absoluteTarget,
+    relativeTarget: normalizeSlashes(path.relative(cwd, absoluteTarget)),
+  });
+}

package/src/domain/registryModel.ts

@@ -0,0 +1,100 @@
+import type { RegistryFile, RegistryItem, RegistrySourceMeta } from "../types.js";
+import { err, ok, type Result } from "../core/result.js";
+import { appError, type AppError } from "../core/errors.js";
+
+type JsonRecord = Record<string, unknown>;
+
+function asStringArray(value: unknown): string[] {
+  if (!value) {
+    return [];
+  }
+  if (Array.isArray(value)) {
+    return value.filter((entry): entry is string => typeof entry === "string");
+  }
+  if (typeof value === "string") {
+    return [value];
+  }
+  return [];
+}
+
+function asObjectArray<T extends JsonRecord>(value: unknown): T[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter((entry): entry is T => Boolean(entry && typeof entry === "object"));
+}
+
+export function normalizeItem(rawItem: JsonRecord, sourceMeta: RegistrySourceMeta): RegistryItem {
+  const rawFiles = asObjectArray<JsonRecord>(rawItem.files);
+  const files: RegistryFile[] = rawFiles.map((file) => ({
+    path: typeof file.path === "string" ? file.path : undefined,
+    target: typeof file.target === "string" ? file.target : undefined,
+    type:
+      typeof file.type === "string"
+        ? file.type
+        : typeof rawItem.type === "string"
+          ? rawItem.type
+          : "registry:file",
+    content: typeof file.content === "string" ? file.content : undefined,
+    url: typeof file.url === "string" ? file.url : undefined,
+  }));
+
+  const name =
+    typeof rawItem.name === "string"
+      ? rawItem.name
+      : typeof rawItem.title === "string"
+        ? rawItem.title
+        : "unnamed-item";
+
+  return {
+    name,
+    title: typeof rawItem.title === "string" ? rawItem.title : name,
+    description: typeof rawItem.description === "string" ? rawItem.description : "",
+    type: typeof rawItem.type === "string" ? rawItem.type : "registry:file",
+    dependencies: asStringArray(rawItem.dependencies),
+    devDependencies: asStringArray(rawItem.devDependencies),
+    registryDependencies: asStringArray(rawItem.registryDependencies),
+    files,
+    sourceMeta,
+  };
+}
+
+export function extractItemReferences(payload: JsonRecord): string[] {
+  const items = asObjectArray<JsonRecord>(payload.items);
+  return items
+    .map((entry) => {
+      if (Array.isArray(entry.files)) {
+        return null;
+      }
+      return typeof entry.url === "string"
+        ? entry.url
+        : typeof entry.href === "string"
+          ? entry.href
+          : typeof entry.path === "string"
+            ? entry.path
+            : null;
+    })
+    .filter((value): value is string => Boolean(value));
+}
+
+export function normalizeManifestInline(data: unknown, sourceMeta: RegistrySourceMeta): Result<RegistryItem[], AppError> {
+  if (Array.isArray(data)) {
+    const items = data
+      .filter((entry): entry is JsonRecord => Boolean(entry && typeof entry === "object"))
+      .map((entry) => normalizeItem(entry, sourceMeta));
+    return ok(items);
+  }
+
+  if (data && typeof data === "object" && Array.isArray((data as JsonRecord).items)) {
+    const entries = asObjectArray<JsonRecord>((data as JsonRecord).items).filter((entry) =>
+      Array.isArray(entry.files),
+    );
+    return ok(entries.map((entry) => normalizeItem(entry, sourceMeta)));
+  }
+
+  if (data && typeof data === "object" && Array.isArray((data as JsonRecord).files)) {
+    return ok([normalizeItem(data as JsonRecord, sourceMeta)]);
+  }
+
+  return err(appError("RegistryError", "Unsupported manifest structure."));
+}

package/src/domain/selection.ts

@@ -0,0 +1,47 @@
+import { appError, type AppError } from "../core/errors.js";
+import { err, ok, type Result } from "../core/result.js";
+import type { CommandContext, RegistryItem } from "../types.js";
+
+export function parseSelectedNames(rawSelectFlag: string | boolean | undefined): string[] {
+  if (!rawSelectFlag) {
+    return [];
+  }
+
+  return String(rawSelectFlag)
+    .split(",")
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+}
+
+export function filterItemsByQuery(items: RegistryItem[], query: string): RegistryItem[] {
+  if (!query) {
+    return items;
+  }
+
+  const lowered = query.toLowerCase();
+  return items.filter((item) => {
+    return (
+      item.name.toLowerCase().includes(lowered) ||
+      item.title.toLowerCase().includes(lowered) ||
+      (item.description || "").toLowerCase().includes(lowered)
+    );
+  });
+}
+
+export function selectItemsFromFlags(items: RegistryItem[], context: CommandContext): Result<RegistryItem[] | null, AppError> {
+  const { flags } = context.args;
+  const explicit = parseSelectedNames(flags.select);
+  if (Boolean(flags.all)) {
+    return ok(items);
+  }
+
+  if (explicit.length) {
+    const selected = items.filter((item) => explicit.includes(item.name));
+    if (!selected.length) {
+      return err(appError("ValidationError", `No items matched --select=${String(flags.select)}`));
+    }
+    return ok(selected);
+  }
+
+  return ok(null);
+}

package/src/index.ts

@@ -0,0 +1,117 @@
+import path from "node:path";
+import pc from "picocolors";
+
+import type { CommandContext, CommandOutcome } from "./types.js";
+import { type AppError, toAppError } from "./core/errors.js";
+import type { Result } from "./core/result.js";
+import { runAddCommand } from "./commands/add.js";
+import { runInitCommand } from "./commands/init.js";
+import { runListCommand } from "./commands/list.js";
+import { runUpdateCommand } from "./commands/update.js";
+import { runPackCommand } from "./commands/pack.js";
+import { parseCliArgs } from "./shell/cli/args.js";
+import { createRuntimePorts } from "./shell/runtime/ports.js";
+
+function printHelp(): void {
+  console.log(`
+Usage:
+  regpick init
+  regpick list [registry-name-or-url]
+  regpick add [registry-name-or-url]
+  regpick update
+  regpick pack [directory]
+
+Options:
+  --cwd=<path>           Working directory (default: current directory)
+  --all                  Select all items in add flow
+  --select=a,b,c         Select explicit item names in add flow
+  --yes                  Skip confirmation prompts where safe
+  --help                 Show this help
+`);
+}
+
+async function run(): Promise<void> {
+  const abortController = new AbortController();
+  
+  // Abort prompts on background errors or process termination
+  const handleTerminate = (err?: Error) => {
+    if (!abortController.signal.aborted) {
+      abortController.abort(err);
+    }
+    if (err instanceof Error) {
+      console.error(pc.red(`\n[Fatal Error] ${err.message}`));
+    }
+    process.exit(1);
+  };
+  
+  process.on("SIGINT", () => handleTerminate());
+  process.on("SIGTERM", () => handleTerminate());
+  process.on("uncaughtException", handleTerminate);
+  process.on("unhandledRejection", (reason) => handleTerminate(reason instanceof Error ? reason : new Error(String(reason))));
+
+  const runtime = createRuntimePorts({ signal: abortController.signal });
+  const parsed = parseCliArgs(process.argv.slice(2));
+  const command = parsed.positionals[0];
+
+  if (!command || parsed.flags.help) {
+    printHelp();
+    return;
+  }
+
+  const context: CommandContext = {
+    cwd: parsed.flags.cwd ? path.resolve(process.cwd(), String(parsed.flags.cwd)) : process.cwd(),
+    args: parsed,
+    runtime,
+  };
+
+  runtime.prompt.intro(pc.cyan("regpick"));
+
+  try {
+    let result: Result<CommandOutcome, AppError>;
+    if (command === "init") {
+      result = await runInitCommand(context);
+    } else if (command === "list") {
+      result = await runListCommand(context);
+    } else if (command === "add") {
+      result = await runAddCommand(context);
+    } else if (command === "update") {
+      result = await runUpdateCommand(context);
+    } else if (command === "pack") {
+      result = await runPackCommand(context);
+    } else {
+      runtime.prompt.error(`Unknown command: ${command}`);
+      printHelp();
+      process.exitCode = 1;
+      return;
+    }
+
+    if (!result.ok) {
+      handleAppError(result.error, runtime.prompt.error);
+      runtime.prompt.outro(pc.red("Failed."));
+      process.exitCode = 1;
+      return;
+    }
+
+    if (result.value.kind === "noop") {
+      runtime.prompt.outro(pc.yellow(result.value.message));
+      return;
+    }
+
+    runtime.prompt.outro(pc.green("Done."));
+  } catch (error) {
+    const appErr = toAppError(error);
+    handleAppError(appErr, runtime.prompt.error);
+    runtime.prompt.outro(pc.red("Failed."));
+    process.exitCode = 1;
+  }
+}
+
+function handleAppError(error: AppError, write: (message: string) => void): void {
+  if (error.kind === "UserCancelled") {
+    write(error.message);
+    return;
+  }
+  write(`[${error.kind}] ${error.message}`);
+}
+
+void run();

package/src/shell/cli/args.ts

@@ -0,0 +1,37 @@
+import type { CliArgs, FlagValue } from "../../types.js";
+
+function parseValue(rawValue: string): FlagValue {
+  if (rawValue === "true") {
+    return true;
+  }
+  if (rawValue === "false") {
+    return false;
+  }
+  return rawValue;
+}
+
+export function parseCliArgs(argv: string[]): CliArgs {
+  const flags: Record<string, FlagValue> = {};
+  const positionals: string[] = [];
+
+  for (const token of argv) {
+    if (!token.startsWith("--")) {
+      positionals.push(token);
+      continue;
+    }
+
+    const withoutPrefix = token.slice(2);
+    const separatorIndex = withoutPrefix.indexOf("=");
+
+    if (separatorIndex === -1) {
+      flags[withoutPrefix] = true;
+      continue;
+    }
+
+    const key = withoutPrefix.slice(0, separatorIndex);
+    const value = withoutPrefix.slice(separatorIndex + 1);
+    flags[key] = parseValue(value);
+  }
+
+  return { flags, positionals };
+}

package/src/shell/config.ts

@@ -0,0 +1,105 @@
+import path from "node:path";
+import fs from "node:fs/promises";
+import { cosmiconfig } from "cosmiconfig";
+
+import type { RegpickConfig } from "../types.js";
+
+const DEFAULT_CONFIG: RegpickConfig = {
+  registries: {
+    tebra: "./tebra-icon-registry/registry",
+  },
+  targetsByType: {
+    "registry:icon": "src/components/ui/icons",
+    "registry:component": "src/components/ui",
+    "registry:file": "src/components/ui",
+  },
+  aliases: {},
+  overwritePolicy: "prompt",
+  packageManager: "auto",
+  preferManifestTarget: true,
+  allowOutsideProject: false,
+};
+
+export function getConfigPath(cwd: string): string {
+  return path.join(cwd, "regpick.json");
+}
+
+export async function readConfig(cwd: string): Promise<{
+  config: RegpickConfig;
+  configPath: string | null;
+}> {
+  const explorer = cosmiconfig("regpick", {
+    searchPlaces: ["regpick.json", ".regpickrc", ".regpickrc.json"],
+  });
+
+  const result = await explorer.search(cwd);
+
+  if (!result || !result.config) {
+    return {
+      config: { ...DEFAULT_CONFIG },
+      configPath: null,
+    };
+  }
+
+  const config = result.config as Partial<RegpickConfig>;
+
+  return {
+    config: {
+      ...DEFAULT_CONFIG,
+      ...config,
+      registries: {
+        ...DEFAULT_CONFIG.registries,
+        ...(config.registries || {}),
+      },
+      targetsByType: {
+        ...DEFAULT_CONFIG.targetsByType,
+        ...(config.targetsByType || {}),
+      },
+      aliases: {
+        ...DEFAULT_CONFIG.aliases,
+        ...(config.aliases || {}),
+      },
+    },
+    configPath: result.filepath,
+  };
+}
+
+export async function writeDefaultConfig(
+  cwd: string,
+  { overwrite = false }: { overwrite?: boolean } = {},
+): Promise<{ filePath: string; written: boolean }> {
+  return writeConfig(cwd, DEFAULT_CONFIG, { overwrite });
+}
+
+export async function writeConfig(
+  cwd: string,
+  config: RegpickConfig,
+  { overwrite = false }: { overwrite?: boolean } = {},
+): Promise<{ filePath: string; written: boolean }> {
+  const filePath = getConfigPath(cwd);
+  
+  let exists = false;
+  try {
+    await fs.access(filePath);
+    exists = true;
+  } catch {}
+
+  if (exists && !overwrite) {
+    return { filePath, written: false };
+  }
+
+  await fs.writeFile(filePath, JSON.stringify(config, null, 2), "utf8");
+  return { filePath, written: true };
+}
+
+export function resolveRegistrySource(input: string | undefined, config: RegpickConfig): string | null {
+  if (!input) {
+    return null;
+  }
+
+  if (config.registries[input]) {
+    return String(config.registries[input]);
+  }
+
+  return input;
+}