regpick 0.2.3

package/src/commands/init.ts

@@ -0,0 +1,89 @@
+import { appError, type AppError } from "../core/errors.js";
+import { err, ok, type Result } from "../core/result.js";
+import type { CommandContext, CommandOutcome } from "../types.js";
+import {
+  decideInitAfterFirstWrite,
+  decideInitAfterOverwritePrompt,
+} from "../domain/initCore.js";
+import { getConfigPath, writeConfig, readConfig } from "../shell/config.js";
+
+export async function runInitCommand(
+  context: CommandContext,
+): Promise<Result<CommandOutcome, AppError>> {
+  const outputPath = getConfigPath(context.cwd);
+  const existsRes = await context.runtime.fs.stat(outputPath);
+  
+  if (existsRes.ok) {
+    const shouldOverwrite = await context.runtime.prompt.confirm({
+      message: `${outputPath} already exists. Overwrite?`,
+      initialValue: false,
+    });
+
+    const secondDecision = decideInitAfterOverwritePrompt(
+      context.runtime.prompt.isCancel(shouldOverwrite),
+      Boolean(shouldOverwrite),
+    );
+    if (secondDecision === "cancelled") {
+      return err(appError("UserCancelled", "Operation cancelled."));
+    }
+
+    if (secondDecision === "keep") {
+      context.runtime.prompt.info("Keeping existing configuration.");
+      return ok({ kind: "noop", message: "Keeping existing configuration." });
+    }
+  }
+
+  const { config: existingConfig } = await readConfig(context.cwd);
+
+  const packageManager = await context.runtime.prompt.select({
+    message: "Jakiego menedżera pakietów używasz?",
+    options: [
+      { value: "auto", label: "Auto (wykrywanie)" },
+      { value: "npm", label: "npm" },
+      { value: "yarn", label: "yarn" },
+      { value: "pnpm", label: "pnpm" }
+    ],
+  });
+
+  if (context.runtime.prompt.isCancel(packageManager)) {
+    return err(appError("UserCancelled", "Operation cancelled."));
+  }
+
+  const componentsFolder = await context.runtime.prompt.text({
+    message: "W jakim folderze trzymasz komponenty UI?",
+    placeholder: "src/components/ui",
+  });
+
+  if (context.runtime.prompt.isCancel(componentsFolder)) {
+    return err(appError("UserCancelled", "Operation cancelled."));
+  }
+
+  const overwritePolicy = await context.runtime.prompt.select({
+    message: "Czy chcesz nadpisywać pliki automatycznie, czy wolisz być pytany?",
+    options: [
+      { value: "prompt", label: "Pytaj (prompt)" },
+      { value: "overwrite", label: "Zawsze nadpisuj (overwrite)" },
+      { value: "skip", label: "Pomijaj nadpisywanie (skip)" }
+    ],
+  });
+
+  if (context.runtime.prompt.isCancel(overwritePolicy)) {
+    return err(appError("UserCancelled", "Operation cancelled."));
+  }
+
+  const newConfig = {
+    ...existingConfig,
+    packageManager: String(packageManager) as any,
+    overwritePolicy: String(overwritePolicy) as any,
+    targetsByType: {
+      ...existingConfig.targetsByType,
+      "registry:component": String(componentsFolder || "src/components/ui"),
+      "registry:file": String(componentsFolder || "src/components/ui"),
+      "registry:icon": `${String(componentsFolder || "src/components/ui")}/icons`,
+    }
+  };
+
+  await writeConfig(context.cwd, newConfig, { overwrite: true });
+  context.runtime.prompt.success(`${existsRes.ok ? "Overwrote" : "Created"} ${outputPath}`);
+  return ok({ kind: "success", message: `${existsRes.ok ? "Overwrote" : "Created"} ${outputPath}` });
+}

package/src/commands/list.ts

@@ -0,0 +1,54 @@
+import { appError, type AppError } from "../core/errors.js";
+import { err, ok, type Result } from "../core/result.js";
+import type { CommandContext, CommandOutcome, RegistryItem } from "../types.js";
+import { resolveListSourceDecision } from "../domain/listCore.js";
+import { readConfig } from "../shell/config.js";
+import { loadRegistry } from "../shell/registry.js";
+
+function formatItemLabel(item: RegistryItem): string {
+  const type = item.type || "registry:file";
+  const fileCount = Array.isArray(item.files) ? item.files.length : 0;
+  return `${item.name} (${type}, files: ${fileCount})`;
+}
+
+export async function runListCommand(
+  context: CommandContext,
+): Promise<Result<CommandOutcome, AppError>> {
+  const { config } = await readConfig(context.cwd);
+  const sourceDecision = resolveListSourceDecision(context.args.positionals[1], config.registries);
+
+  let source = sourceDecision.source;
+  if (sourceDecision.requiresPrompt) {
+    const response = await context.runtime.prompt.text({
+      message: "Registry URL/path:",
+      placeholder: "https://example.com/registry.json",
+    });
+
+    if (context.runtime.prompt.isCancel(response)) {
+      return err(appError("UserCancelled", "Operation cancelled."));
+    }
+
+    source = String(response);
+  }
+
+  if (!source) {
+    return ok({ kind: "noop", message: "No registry source provided." });
+  }
+
+  const registryResult = await loadRegistry(source, context.cwd, context.runtime);
+  if (!registryResult.ok) {
+    return registryResult;
+  }
+
+  const { items } = registryResult.value;
+  if (!items.length) {
+    context.runtime.prompt.warn("No items found in registry.");
+    return ok({ kind: "noop", message: "No items found in registry." });
+  }
+
+  context.runtime.prompt.info(`Found ${items.length} items.`);
+  for (const item of items) {
+    console.log(`- ${formatItemLabel(item)}`);
+  }
+  return ok({ kind: "success", message: `Listed ${items.length} item(s).` });
+}

package/src/commands/pack.ts

@@ -0,0 +1,97 @@
+import path from "node:path";
+import pc from "picocolors";
+
+import { appError, type AppError } from "../core/errors.js";
+import { err, ok, type Result } from "../core/result.js";
+import type { CommandContext, CommandOutcome, RegistryItem } from "../types.js";
+import { extractDependencies } from "../domain/packCore.js";
+
+async function getFilesRecursive(
+  dir: string,
+  context: CommandContext,
+): Promise<Result<string[], AppError>> {
+  const result: string[] = [];
+  
+  async function scan(currentDir: string): Promise<Result<void, AppError>> {
+    const dirRes = await context.runtime.fs.readdir(currentDir);
+    if (!dirRes.ok) return dirRes;
+    
+    for (const file of dirRes.value) {
+      const fullPath = path.join(currentDir, file);
+      const statRes = await context.runtime.fs.stat(fullPath);
+      if (!statRes.ok) return statRes;
+      
+      if (statRes.value.isDirectory()) {
+        const scanRes = await scan(fullPath);
+        if (!scanRes.ok) return scanRes;
+      } else {
+        if (fullPath.endsWith(".ts") || fullPath.endsWith(".tsx")) {
+          result.push(fullPath);
+        }
+      }
+    }
+    return ok(undefined);
+  }
+
+  const scanRes = await scan(dir);
+  if (!scanRes.ok) return err(scanRes.error);
+  return ok(result);
+}
+
+export async function runPackCommand(
+  context: CommandContext,
+): Promise<Result<CommandOutcome, AppError>> {
+  const targetDirArg = context.args.positionals[1] || ".";
+  const targetDir = path.resolve(context.cwd, targetDirArg);
+
+  const statRes = await context.runtime.fs.stat(targetDir);
+  if (!statRes.ok || !statRes.value.isDirectory()) {
+    return err(appError("ValidationError", `Target is not a directory: ${targetDir}`));
+  }
+
+  context.runtime.prompt.info(`Scanning ${targetDir} for components...`);
+
+  const filesRes = await getFilesRecursive(targetDir, context);
+  if (!filesRes.ok) return filesRes;
+
+  const files = filesRes.value;
+  if (files.length === 0) {
+    context.runtime.prompt.warn("No .ts or .tsx files found.");
+    return ok({ kind: "noop", message: "No files found." });
+  }
+
+  const items: RegistryItem[] = [];
+
+  for (const file of files) {
+    const contentRes = await context.runtime.fs.readFile(file, "utf8");
+    if (!contentRes.ok) return err(contentRes.error);
+
+    const dependencies = extractDependencies(contentRes.value);
+    const relativePath = path.relative(targetDir, file).replace(/\\/g, "/");
+    const name = path.basename(file, path.extname(file));
+
+    items.push({
+      name,
+      title: name,
+      description: "Packed component",
+      type: "registry:component",
+      dependencies,
+      devDependencies: [],
+      registryDependencies: [],
+      files: [
+        {
+          path: relativePath,
+          type: "registry:component",
+        },
+      ],
+    } as any);
+  }
+
+  const registry = { items };
+  const outPath = path.join(context.cwd, "registry.json");
+  const writeRes = await context.runtime.fs.writeJson(outPath, registry, { spaces: 2 });
+  if (!writeRes.ok) return err(writeRes.error);
+
+  context.runtime.prompt.success(`Packed ${items.length} components into registry.json`);
+  return ok({ kind: "success", message: `Generated registry.json` });
+}

package/src/commands/update.ts

@@ -0,0 +1,139 @@
+import path from "node:path";
+import pc from "picocolors";
+import * as diff from "diff";
+
+import { appError, type AppError } from "../core/errors.js";
+import { err, ok, type Result } from "../core/result.js";
+import type { CommandContext, CommandOutcome, RegistryItem } from "../types.js";
+import { readLockfile, computeHash, writeLockfile } from "../shell/lockfile.js";
+import { loadRegistry, resolveFileContent } from "../shell/registry.js";
+import { resolveOutputPathFromPolicy } from "../domain/pathPolicy.js";
+import { readConfig } from "../shell/config.js";
+import { applyAliases } from "../domain/aliasCore.js";
+
+function printDiff(oldContent: string, newContent: string) {
+  const changes = diff.diffLines(oldContent, newContent);
+  for (const part of changes) {
+    const color = part.added ? pc.green : part.removed ? pc.red : pc.gray;
+    const prefix = part.added ? "+ " : part.removed ? "- " : "  ";
+    const lines = part.value.replace(/\n$/, "").split("\n");
+    for (const line of lines) {
+      console.log(color(`${prefix}${line}`));
+    }
+  }
+}
+
+export async function runUpdateCommand(
+  context: CommandContext,
+): Promise<Result<CommandOutcome, AppError>> {
+  const lockfile = await readLockfile(context.cwd, context.runtime);
+  const componentNames = Object.keys(lockfile.components);
+
+  if (componentNames.length === 0) {
+    context.runtime.prompt.info("No components installed. Nothing to update.");
+    return ok({ kind: "noop", message: "No components to update." });
+  }
+
+  const { config } = await readConfig(context.cwd);
+
+  // Group by source
+  const bySource: Record<string, string[]> = {};
+  for (const name of componentNames) {
+    const source = lockfile.components[name].source;
+    if (source) {
+      if (!bySource[source]) bySource[source] = [];
+      bySource[source].push(name);
+    }
+  }
+
+  let updatedCount = 0;
+
+  for (const [source, itemsToUpdate] of Object.entries(bySource)) {
+    const registryRes = await loadRegistry(source, context.cwd, context.runtime);
+    if (!registryRes.ok) {
+      context.runtime.prompt.warn(`Failed to load registry ${source}`);
+      continue;
+    }
+
+    const registryItems = registryRes.value.items;
+    
+    for (const itemName of itemsToUpdate) {
+      const registryItem = registryItems.find(i => i.name === itemName);
+      if (!registryItem) continue;
+
+      // Get remote contents
+      const remoteContents: string[] = [];
+      const remoteFiles: { target: string; content: string }[] = [];
+      
+      for (const file of registryItem.files) {
+        const contentRes = await resolveFileContent(file, registryItem, context.cwd, context.runtime);
+        if (!contentRes.ok) continue;
+
+        let content = applyAliases(contentRes.value, config);
+        remoteContents.push(content);
+        
+        const outputRes = resolveOutputPathFromPolicy(registryItem, file, context.cwd, config);
+        if (outputRes.ok) {
+           remoteFiles.push({ target: outputRes.value.absoluteTarget, content: content });
+        }
+      }
+      
+      const newHash = computeHash(remoteContents.sort().join(""));
+      const currentHash = lockfile.components[itemName].hash;
+
+      if (newHash !== currentHash) {
+        context.runtime.prompt.info(`Update available for ${itemName}`);
+        
+        const action = await context.runtime.prompt.select({
+          message: `What do you want to do with ${itemName}?`,
+          options: [
+            { value: "diff", label: "Show diff" },
+            { value: "update", label: "Update" },
+            { value: "skip", label: "Skip" }
+          ]
+        });
+
+        if (context.runtime.prompt.isCancel(action) || action === "skip") {
+          continue;
+        }
+
+        if (action === "diff") {
+          for (const rf of remoteFiles) {
+             const localContentRes = await context.runtime.fs.readFile(rf.target, "utf8");
+             const localContent = localContentRes.ok ? localContentRes.value : "";
+             console.log(pc.bold(`\nDiff for ${rf.target}:`));
+             printDiff(localContent, rf.content);
+          }
+          
+          const confirm = await context.runtime.prompt.confirm({
+             message: `Update ${itemName} now?`,
+             initialValue: true
+          });
+          
+          if (context.runtime.prompt.isCancel(confirm) || !confirm) {
+             continue;
+          }
+        }
+
+        // Apply update
+        for (const rf of remoteFiles) {
+          const ensureRes = await context.runtime.fs.ensureDir(path.dirname(rf.target));
+          if (!ensureRes.ok) return ensureRes;
+          const writeRes = await context.runtime.fs.writeFile(rf.target, rf.content, "utf8");
+          if (!writeRes.ok) return writeRes;
+        }
+
+        lockfile.components[itemName].hash = newHash;
+        updatedCount++;
+        context.runtime.prompt.success(`Updated ${itemName}`);
+      }
+    }
+  }
+
+  if (updatedCount > 0) {
+    await writeLockfile(context.cwd, lockfile, context.runtime);
+    return ok({ kind: "success", message: `Updated ${updatedCount} components.` });
+  }
+
+  return ok({ kind: "noop", message: "All components are up to date." });
+}

package/src/core/__tests__/result-errors.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from "vitest";
+
+import { appError, toAppError } from "../errors.js";
+import { err, isErr, isOk, ok } from "../result.js";
+
+describe("result and error model", () => {
+  it("creates ok/err results", () => {
+    const success = ok(42);
+    const failure = err(appError("ValidationError", "invalid"));
+    expect(isOk(success)).toBe(true);
+    expect(isErr(failure)).toBe(true);
+  });
+
+  it("normalizes unknown to AppError", () => {
+    const converted = toAppError(new Error("boom"), "RuntimeError");
+    expect(converted.kind).toBe("RuntimeError");
+    expect(converted.message).toBe("boom");
+  });
+});

package/src/core/errors.ts

@@ -0,0 +1,36 @@
+export type AppErrorKind =
+  | "ConfigError"
+  | "RegistryError"
+  | "InstallError"
+  | "UserCancelled"
+  | "ValidationError"
+  | "RuntimeError";
+
+export type AppError = {
+  kind: AppErrorKind;
+  message: string;
+  cause?: unknown;
+};
+
+export function appError(kind: AppErrorKind, message: string, cause?: unknown): AppError {
+  return { kind, message, cause };
+}
+
+export function toAppError(error: unknown, fallbackKind: AppErrorKind = "RuntimeError"): AppError {
+  if (
+    typeof error === "object" &&
+    error !== null &&
+    "kind" in error &&
+    "message" in error &&
+    typeof (error as { kind?: unknown }).kind === "string" &&
+    typeof (error as { message?: unknown }).message === "string"
+  ) {
+    return error as AppError;
+  }
+
+  if (error instanceof Error) {
+    return appError(fallbackKind, error.message, error);
+  }
+
+  return appError(fallbackKind, String(error));
+}

package/src/core/result.ts

@@ -0,0 +1,19 @@
+export type Ok<T> = { ok: true; value: T };
+export type Err<E> = { ok: false; error: E };
+export type Result<T, E> = Ok<T> | Err<E>;
+
+export function ok<T>(value: T): Ok<T> {
+  return { ok: true, value };
+}
+
+export function err<E>(error: E): Err<E> {
+  return { ok: false, error };
+}
+
+export function isOk<T, E>(result: Result<T, E>): result is Ok<T> {
+  return result.ok;
+}
+
+export function isErr<T, E>(result: Result<T, E>): result is Err<E> {
+  return !result.ok;
+}

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

@@ -0,0 +1,64 @@
+import { describe, expect, it } from "vitest";
+
+import type { RegpickConfig, RegistryItem } from "../../types.js";
+import { buildInstallPlan } from "../addPlan.js";
+
+const config: RegpickConfig = {
+  registries: {},
+  targetsByType: {
+    "registry:icon": "src/components/ui/icons",
+    "registry:file": "src/components/ui",
+  },
+  overwritePolicy: "prompt",
+  packageManager: "auto",
+  preferManifestTarget: false,
+  allowOutsideProject: false,
+};
+
+const items: RegistryItem[] = [
+  {
+    name: "check",
+    title: "Check",
+    description: "",
+    type: "registry:icon",
+    dependencies: ["react"],
+    devDependencies: ["@types/react"],
+    registryDependencies: [],
+    files: [{ type: "registry:file", path: "icons/check.tsx" }],
+    sourceMeta: { type: "directory", baseDir: "/registry" },
+  },
+  {
+    name: "calendar",
+    title: "Calendar",
+    description: "",
+    type: "registry:icon",
+    dependencies: ["react", "clsx"],
+    devDependencies: [],
+    registryDependencies: [],
+    files: [{ type: "registry:file", path: "icons/calendar.tsx" }],
+    sourceMeta: { type: "directory", baseDir: "/registry" },
+  },
+];
+
+describe("add plan core", () => {
+  it("builds deduplicated dependency plan", () => {
+    const planRes = buildInstallPlan(items, "/tmp/project", config);
+    expect(planRes.ok).toBe(true);
+    if (planRes.ok) {
+      expect(planRes.value.dependencyPlan.dependencies).toEqual(["react", "clsx"]);
+      expect(planRes.value.dependencyPlan.devDependencies).toEqual(["@types/react"]);
+    }
+  });
+
+  it("detects conflicts based on existing target paths", () => {
+    const firstPlanRes = buildInstallPlan(items, "/tmp/project", config);
+    expect(firstPlanRes.ok).toBe(true);
+    if (!firstPlanRes.ok) return;
+    const existingTargets = new Set([firstPlanRes.value.plannedWrites[0].absoluteTarget]);
+    const planWithConflictsRes = buildInstallPlan(items, "/tmp/project", config, existingTargets);
+    expect(planWithConflictsRes.ok).toBe(true);
+    if (!planWithConflictsRes.ok) return;
+    expect(planWithConflictsRes.value.conflicts).toHaveLength(1);
+    expect(planWithConflictsRes.value.conflicts[0].itemName).toBe("check");
+  });
+});

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

@@ -0,0 +1,28 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  decideInitAfterFirstWrite,
+  decideInitAfterOverwritePrompt,
+} from "../initCore.js";
+
+describe("init core", () => {
+  it("returns created when first write succeeds", () => {
+    expect(decideInitAfterFirstWrite(true)).toBe("created");
+  });
+
+  it("asks for overwrite when first write does not happen", () => {
+    expect(decideInitAfterFirstWrite(false)).toBe("ask-overwrite");
+  });
+
+  it("returns cancelled when prompt is cancelled", () => {
+    expect(decideInitAfterOverwritePrompt(true, false)).toBe("cancelled");
+  });
+
+  it("returns overwrite when user confirms overwrite", () => {
+    expect(decideInitAfterOverwritePrompt(false, true)).toBe("overwrite");
+  });
+
+  it("returns keep when user rejects overwrite", () => {
+    expect(decideInitAfterOverwritePrompt(false, false)).toBe("keep");
+  });
+});

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

@@ -0,0 +1,29 @@
+import { describe, expect, it } from "vitest";
+
+import type { RegistryItem } from "../../types.js";
+import {
+  resolveListSourceDecision,
+  resolveRegistrySourceFromAliases,
+} from "../listCore.js";
+
+describe("list core", () => {
+  it("resolves alias to configured source", () => {
+    expect(resolveRegistrySourceFromAliases("tebra", { tebra: "./registry" })).toBe("./registry");
+  });
+
+  it("uses provided input first", () => {
+    const decision = resolveListSourceDecision("tebra", { tebra: "./registry" });
+    expect(decision).toEqual({ source: "./registry", requiresPrompt: false });
+  });
+
+  it("uses first alias when input is missing", () => {
+    const decision = resolveListSourceDecision(undefined, { alpha: "./a", beta: "./b" });
+    expect(decision).toEqual({ source: "./a", requiresPrompt: false });
+  });
+
+  it("requires prompt when no input and no aliases", () => {
+    const decision = resolveListSourceDecision(undefined, {});
+    expect(decision).toEqual({ source: null, requiresPrompt: true });
+  });
+
+});

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

@@ -0,0 +1,64 @@
+import { describe, expect, it } from "vitest";
+
+import type { RegpickConfig, RegistryItem } from "../../types.js";
+import { resolveOutputPathFromPolicy } from "../pathPolicy.js";
+
+const baseConfig: RegpickConfig = {
+  registries: {},
+  targetsByType: {
+    "registry:icon": "src/components/ui/icons",
+    "registry:file": "src/components/ui",
+  },
+  overwritePolicy: "prompt",
+  packageManager: "auto",
+  preferManifestTarget: true,
+  allowOutsideProject: false,
+};
+
+const item: RegistryItem = {
+  name: "check",
+  title: "Check",
+  description: "",
+  type: "registry:icon",
+  dependencies: [],
+  devDependencies: [],
+  registryDependencies: [],
+  files: [{ type: "registry:file", path: "icons/check.tsx", target: "src/custom/check.tsx" }],
+  sourceMeta: { type: "directory", baseDir: "/registry" },
+};
+
+describe("path policy core", () => {
+  it("prefers manifest target by default", () => {
+    const outputRes = resolveOutputPathFromPolicy(item, item.files[0], "/tmp/project", baseConfig);
+    expect(outputRes.ok).toBe(true);
+    if (outputRes.ok) {
+      expect(outputRes.value.relativeTarget).toBe("src/custom/check.tsx");
+    }
+  });
+
+  it("uses mapped type target when preferManifestTarget is false", () => {
+    const outputRes = resolveOutputPathFromPolicy(
+      item,
+      item.files[0],
+      "/tmp/project",
+      { ...baseConfig, preferManifestTarget: false },
+    );
+    expect(outputRes.ok).toBe(true);
+    if (outputRes.ok) {
+      expect(outputRes.value.relativeTarget).toBe("src/components/ui/check.tsx");
+    }
+  });
+
+  it("blocks writes outside project root", () => {
+    const outputRes = resolveOutputPathFromPolicy(
+      item,
+      { ...item.files[0], target: "../outside/check.tsx" },
+      "/tmp/project",
+      baseConfig,
+    );
+    expect(outputRes.ok).toBe(false);
+    if (!outputRes.ok) {
+      expect(outputRes.error.message).toMatch(/Refusing to write outside project/);
+    }
+  });
+});

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

@@ -0,0 +1,32 @@
+import { describe, expect, it } from "vitest";
+
+import { extractItemReferences, normalizeManifestInline } from "../registryModel.js";
+
+describe("registry model core", () => {
+  it("normalizes inline items from registry.json", () => {
+    const payload = {
+      items: [
+        {
+          name: "check",
+          type: "registry:icon",
+          files: [{ path: "icons/check.tsx", type: "registry:file" }],
+        },
+        { name: "external", url: "./external-item.json" },
+      ],
+    };
+
+    const normalized = normalizeManifestInline(payload, { type: "file", baseDir: "/registry" });
+    expect(normalized.ok).toBe(true);
+    if (normalized.ok) {
+      expect(normalized.value).toHaveLength(1);
+      expect(normalized.value[0].name).toBe("check");
+    }
+  });
+
+  it("extracts item references from registry.json entries", () => {
+    const payload = {
+      items: [{ name: "a", url: "./a.json" }, { name: "b", href: "./b.json" }, { name: "c", path: "./c.json" }],
+    };
+    expect(extractItemReferences(payload)).toEqual(["./a.json", "./b.json", "./c.json"]);
+  });
+});