components-differ 1.2.1 → 1.2.3

package/src/extract-imports.ts

@@ -0,0 +1,87 @@
+/**
+ * Extract npm package names from import/require statements in source code.
+ * Used to include only dependencies that are actually used by the registry item files.
+ */
+
+/**
+ * Returns the root package name for a specifier. Handles scoped packages and subpaths.
+ * - "react" -> "react"
+ * - "lodash/merge" -> "lodash"
+ * - "@scope/pkg" -> "@scope/pkg"
+ * - "@scope/pkg/sub" -> "@scope/pkg"
+ */
+function specifierToPackageName(specifier: string): string | null {
+  const s = specifier.trim();
+  if (!s) return null;
+  // Node / bundler builtins
+  if (s.startsWith("node:") || s === "node") return null;
+  // Relative imports – not packages
+  if (s.startsWith(".") || s.startsWith("/")) return null;
+  // Common path aliases (not package names)
+  if (s.startsWith("@/") || s.startsWith("~/") || s.startsWith("#")) return null;
+  // Scoped package: @scope/pkg or @scope/pkg/subpath
+  if (s.startsWith("@")) {
+    const firstSlash = s.indexOf("/");
+    if (firstSlash === -1) return s;
+    const secondSlash = s.indexOf("/", firstSlash + 1);
+    return secondSlash === -1 ? s : s.slice(0, secondSlash);
+  }
+  // Normal package or subpath
+  const slash = s.indexOf("/");
+  return slash === -1 ? s : s.slice(0, slash);
+}
+
+const RE_IMPORT =
+  /(?:import\s+(?:(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)\s+from\s+)?|import\s*)['"]([^'"]+)['"]|require\s*\(\s*['"]([^'"]+)['"]\s*\)|import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+
+/**
+ * Collect all package names that are imported or required in the given file content.
+ */
+function extractFromContent(content: string): Set<string> {
+  const packages = new Set<string>();
+  let m: RegExpExecArray | null;
+  RE_IMPORT.lastIndex = 0;
+  while ((m = RE_IMPORT.exec(content)) !== null) {
+    const specifier = (m[1] ?? m[2] ?? m[3]) ?? "";
+    const pkg = specifierToPackageName(specifier);
+    if (pkg) packages.add(pkg);
+  }
+  return packages;
+}
+
+/**
+ * Collect all package names imported by any of the given files (by their content).
+ */
+export function extractImportedPackages(files: { content: string }[]): Set<string> {
+  const all = new Set<string>();
+  for (const { content } of files) {
+    for (const pkg of extractFromContent(content)) {
+      all.add(pkg);
+    }
+  }
+  return all;
+}
+
+/** True if the import specifier refers to a project file (relative or path alias), not npm. */
+export function isPathSpecifier(specifier: string): boolean {
+  const s = specifier.trim();
+  if (!s || s.startsWith("node:")) return false;
+  if (s.startsWith(".") || s.startsWith("/")) return true;
+  if (s.startsWith("@/") || s.startsWith("~/") || s.startsWith("#")) return true;
+  return false;
+}
+
+/**
+ * Extract all import/require specifiers that are project paths (relative or alias)
+ * from file content. Used to pull in imported files into the registry.
+ */
+export function extractPathSpecifiers(content: string): string[] {
+  const out: string[] = [];
+  let m: RegExpExecArray | null;
+  RE_IMPORT.lastIndex = 0;
+  while ((m = RE_IMPORT.exec(content)) !== null) {
+    const specifier = (m[1] ?? m[2] ?? m[3]) ?? "";
+    if (isPathSpecifier(specifier)) out.push(specifier);
+  }
+  return out;
+}

package/{dist/src/git.mjs → src/git.ts}

@@ -2,7 +2,6 @@ import fs from "node:fs";
 import path from "node:path";
 import { execSync } from "node:child_process";
 import ignore from "ignore";
-import { start } from "node:repl";
 
 const INITIAL_DIR = "_initial";
 
@@ -32,62 +31,67 @@ const EXCLUDE_FILES = [
   "favicon.ico",
 ];
 
-function cloneInitialCommit() {
+function cloneInitialCommit(): void {
   deleteInitialDir();
 
   try {
-    // Get the initial commit hash
     const initialCommit = execSync("git rev-list --max-parents=0 HEAD")
       .toString()
       .trim();
 
-    // Clone the initial commit quietly
     execSync(`git worktree add -f ${INITIAL_DIR} ${initialCommit}`, {
       stdio: "ignore",
     });
-  } catch (error) {
+  } catch (error: any) {
     console.error("Error cloning initial commit:", error.message);
     process.exit(1);
   }
 }
 
-function deleteInitialDir() {
+function deleteInitialDir(): void {
   if (fs.existsSync(INITIAL_DIR)) {
-    fs.rmSync(INITIAL_DIR, { recursive: true });
+    fs.rmSync(INITIAL_DIR, { recursive: true, force: true });
 
     try {
       execSync("git worktree prune", { stdio: "ignore" });
-    } catch (error) {
+    } catch (error: any) {
       console.error("Error pruning git worktree:", error.message);
     }
   }
 }
 
-function checkIfFileIsChanged(relativeFilePath) {
+function checkIfFileIsChanged(relativeFilePath: string): boolean {
   const initialFilePath = path.join(INITIAL_DIR, relativeFilePath);
   const fullPath = path.join(process.cwd(), relativeFilePath);
   if (!fs.existsSync(initialFilePath)) {
-    return true; // New file
+    return true;
   }
   const currentContent = fs.readFileSync(fullPath, "utf-8");
   const initialContent = fs.readFileSync(initialFilePath, "utf-8");
   return currentContent !== initialContent;
 }
 
-export function scanForFiles(startDir, checkFile = false) {
-  const foundFiles = [];
+export interface ScannedFile {
+  path: string;
+  content: string;
+}
+
+export function scanForFiles(
+  startDir: string,
+  checkFile = false,
+): ScannedFile[] {
+  const foundFiles: ScannedFile[] = [];
 
-  let ignorer = () => false;
-  if (fs.existsSync(path.join(startDir, ".gitignore"))) {
+  let ignorer: (relativeFilePath: string) => boolean = () => false;
+  const gitignorePath = path.join(startDir, ".gitignore");
+  if (fs.existsSync(gitignorePath)) {
     const gitIgnore = ignore().add(
-      fs.readFileSync(path.join(startDir, ".gitignore")).toString()
+      fs.readFileSync(gitignorePath).toString(),
     );
-    ignorer = (relativeFilePath) => {
-      return gitIgnore.ignores(relativeFilePath);
-    };
+    ignorer = (relativeFilePath: string) => gitIgnore.ignores(relativeFilePath);
   }
 
-  function scanDirectory(dir, relativePath = "") {
+  function scanDirectory(dir: string, relativePath = ""): void {
     const entries = fs.readdirSync(dir, { withFileTypes: true });
 
     for (const entry of entries) {
@@ -102,7 +106,10 @@ export function scanForFiles(startDir, checkFile = false) {
         !checkFile ||
         (checkFile && checkIfFileIsChanged(relativeFilePath))
       ) {
-        if (!EXCLUDE_FILES.includes(entry.name) && !ignorer(relativeFilePath)) {
+        if (
+          !EXCLUDE_FILES.includes(entry.name) &&
+          !ignorer(relativeFilePath)
+        ) {
           foundFiles.push({
             path: relativeFilePath,
             content: fs.readFileSync(fullPath, "utf-8"),
@@ -117,16 +124,26 @@ export function scanForFiles(startDir, checkFile = false) {
   return foundFiles.sort((a, b) => a.path.localeCompare(b.path));
 }
 
-export function scanForAlteredFiles(specificFilesToReturn = []) {
+export function scanForAlteredFiles(
+  specificFilesToReturn: string[] = [],
+): {
+  alteredFiles: ScannedFile[];
+  specificFiles: Record<string, string>;
+} {
   cloneInitialCommit();
 
   const alteredFiles = scanForFiles(process.cwd(), true);
 
-  const specificFiles = specificFilesToReturn.reduce((out, file) => {
-    const fullPath = path.join(process.cwd(), INITIAL_DIR, file);
-    out[file] = fs.readFileSync(fullPath, "utf-8");
-    return out;
-  }, {});
+  const specificFiles = specificFilesToReturn.reduce<Record<string, string>>(
+    (out, file) => {
+      const fullPath = path.join(process.cwd(), INITIAL_DIR, file);
+      out[file] = fs.existsSync(fullPath)
+        ? fs.readFileSync(fullPath, "utf-8")
+        : "";
+      return out;
+    },
+    {},
+  );
 
   deleteInitialDir();
 
@@ -136,6 +153,7 @@ export function scanForAlteredFiles(specificFilesToReturn = []) {
   };
 }
 
-export function hasSrcDir(dir) {
+export function hasSrcDir(dir: string): boolean {
   return fs.existsSync(path.join(dir, "src"));
 }
+

package/src/index.ts

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+import { execSync } from "node:child_process";
+import { program } from "commander";
+
+import {
+  scanForAlteredFiles,
+  scanForFiles,
+  hasSrcDir,
+  type ScannedFile,
+} from "./git.js";
+import { readComponentsManifest } from "./components.js";
+import { createDiff } from "./create-diff.js";
+import { expandIncludedFiles } from "./resolve-imports.js";
+
+function runCommand(command: string): void {
+  try {
+    execSync(command, { stdio: "inherit" });
+  } catch (error) {
+    console.error(`Failed to execute command: ${command}`);
+    process.exit(1);
+  }
+}
+
+function ensureGitignore(): void {
+  const gitignorePath = path.join(process.cwd(), ".gitignore");
+  if (!fs.existsSync(gitignorePath)) {
+    const content = `
+/node_modules
+/.pnp
+.pnp.*
+.yarn/*
+!.yarn/patches
+!.yarn/plugins
+!.yarn/releases
+!.yarn/versions
+
+# testing
+/coverage
+
+# next.js
+/.next/
+/out/
+
+# production
+/build
+
+# misc
+.DS_Store
+*.pem
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# env files (can opt-in for committing if needed)
+.env*
+
+# vercel
+.vercel
+
+# typescript
+*.tsbuildinfo
+next-env.d.ts
+`;
+    fs.writeFileSync(gitignorePath, content, "utf8");
+  }
+}
+
+function main(): void {
+  program
+    .option("-n, --name <name>")
+    .option("--init")
+    .option("-f, --folder <folder>", "folder to include (default: current directory)")
+    .option("--git", "use git mode: only files changed since initial commit");
+  program.parse();
+
+  const options = program.opts<{
+    name?: string;
+    init?: boolean;
+    folder?: string;
+    git?: boolean;
+  }>();
+
+  if (options.init) {
+    // Initialize a clean git repository for the current component
+    if (process.platform === "win32") {
+      runCommand(
+        'rmdir /s /q .git && git init && git add . && git commit -m "Initial commit"',
+      );
+    } else {
+      runCommand(
+        'rm -fr .git && git init && git add . && git commit -m "Initial commit"',
+      );
+    }
+    ensureGitignore();
+    return;
+  }
+
+  const useFolderMode = !options.git;
+  const folderOpt = options.folder ?? (useFolderMode ? "." : undefined);
+
+  const baseName = folderOpt != null
+    ? path.basename(path.resolve(process.cwd(), folderOpt))
+    : path.basename(process.cwd());
+  const name = options.name || baseName;
+
+  let alteredFiles: ScannedFile[];
+  let specificFiles: Record<string, string>;
+
+  if (useFolderMode && folderOpt != null) {
+    const folderPath = path.resolve(process.cwd(), folderOpt);
+    if (!fs.existsSync(folderPath) || !fs.statSync(folderPath).isDirectory()) {
+      console.error(
+        `Folder path is not a directory: ${folderOpt}`,
+      );
+      process.exit(1);
+    }
+
+    const folderPrefix = path
+      .relative(process.cwd(), folderPath)
+      .replace(/\\/g, "/")
+      .replace(/^\.\//, "");
+
+    const allFiles = scanForFiles(process.cwd());
+    alteredFiles = allFiles.filter(({ path: filePath }) => {
+      const normalized = filePath.replace(/\\/g, "/");
+      return (
+        normalized === folderPrefix ||
+        normalized.startsWith(`${folderPrefix}/`)
+      );
+    });
+
+    specificFiles = {
+      "./package.json": "{}",
+    };
+  } else {
+    const result = scanForAlteredFiles(["./package.json"]);
+    alteredFiles = result.alteredFiles;
+    specificFiles = result.specificFiles;
+  }
+
+  const currentFiles = scanForFiles(process.cwd());
+
+  const currentPackageJson = fs.readFileSync("./package.json", "utf-8");
+
+  const config = readComponentsManifest(process.cwd());
+  (config as any).isSrcDir = hasSrcDir(process.cwd());
+
+  // Recursively add any project file imported by the included files so the
+  // registry item is self-contained (no "component not found").
+  alteredFiles = expandIncludedFiles(alteredFiles, currentFiles, config as any);
+
+  const output = createDiff({
+    name,
+    config,
+    alteredFiles,
+    currentFiles,
+    specificFiles,
+    currentPackageJson,
+  });
+
+  // Emit a complete registry:block JSON object suitable for local file support
+  // (e.g. `npx shadcn add ./block.json`)
+  // eslint-disable-next-line no-console
+  console.log(JSON.stringify(output, null, 2));
+}
+
+main();
+

package/{dist/src/parse-file-path.mjs → src/parse-file-path.ts}

@@ -1,24 +1,60 @@
 import path from "node:path";
+import type { ComponentsConfig } from "./components.js";
 
-function fixAlias(alias) {
+function fixAlias(alias: string): string {
   return alias.replace("@", ".");
 }
 
-export function parseFilePath(wasInSrcDir, config, filePath, content) {
+export type RegistryFileType =
+  | "registry:example"
+  | "registry:ui"
+  | "registry:block"
+  | "registry:hook"
+  | "registry:lib"
+  | "registry:page"
+  | "registry:theme"
+  | "registry:style"
+  | "registry:file"
+  | "registry:component";
+
+export interface ParsedFile {
+  path: string;
+  content: string;
+  type: RegistryFileType;
+  target?: string;
+}
+
+export function parseFilePath(
+  wasInSrcDir: boolean,
+  config: ComponentsConfig,
+  filePath: string,
+  content: string,
+): ParsedFile {
   const normalizedPath = filePath.replace(/^\.\//, "");
   const extension = path.extname(normalizedPath);
   const baseName = path.basename(normalizedPath);
 
-  const styleExtensions = new Set([".css", ".scss", ".sass", ".less", ".pcss"]);
-  const fileExtensions = new Set([".json", ".yaml", ".yml", ".md", ".mdx", ".txt"]);
+  const styleExtensions = new Set([
+    ".css",
+    ".scss",
+    ".sass",
+    ".less",
+    ".pcss",
+  ]);
+  const fileExtensions = new Set([
+    ".json",
+    ".yaml",
+    ".yml",
+    ".md",
+    ".mdx",
+    ".txt",
+  ]);
   const themePattern = /(\/|^)(theme|.*-theme)(\.[a-z0-9]+)?$/i;
 
   const sanitizedTargetPath = normalizedPath.replace(/^src\//, "");
-  const defaultTarget = wasInSrcDir
-    ? filePath
-    : `~/${normalizedPath}`;
+  const defaultTarget = wasInSrcDir ? filePath : `~/${normalizedPath}`;
 
-  const out = {
+  const out: ParsedFile = {
     path: filePath,
     content,
     type: "registry:example",
@@ -52,13 +88,10 @@ export function parseFilePath(wasInSrcDir, config, filePath, content) {
     out.type = "registry:component";
     out.target = undefined;
   } else {
-    out.type = "registry:item";
-    out.target = undefined;
-  }
-
-  if (out.type === "registry:example") {
-    out.path = filePath;
+    out.type = "registry:file";
+    out.target = `./${sanitizedTargetPath}`;
   }
 
   return out;
 }
+

package/src/release.ts

@@ -0,0 +1,71 @@
+import { spawnSync } from "node:child_process";
+
+type VersionBump = "patch" | "minor" | "major";
+
+function run(command: string, args: string[] = []) {
+  const full = [command, ...args].join(" ");
+  console.log(`\n$ ${full}`);
+
+  const result = spawnSync(command, args, {
+    stdio: "inherit",
+    shell: process.platform === "win32",
+  });
+
+  if (result.status !== 0) {
+    console.error(`\nCommand failed: ${full}`);
+    process.exit(result.status === null ? 1 : result.status);
+  }
+}
+
+function getVersionBumpFromArgs(): VersionBump {
+  const type = (process.argv[2] as VersionBump | undefined) ?? "patch";
+  if (!["patch", "minor", "major"].includes(type)) {
+    console.error(
+      `Invalid version bump "${type}". Use one of: patch, minor, major.`
+    );
+    process.exit(1);
+  }
+  return type;
+}
+
+function ensureCleanGit() {
+  const result = spawnSync("git", ["status", "--porcelain"], {
+    encoding: "utf8",
+  });
+
+  if (result.status !== 0) {
+    console.error("Failed to check git status.");
+    process.exit(1);
+  }
+
+  if ((result.stdout ?? "").trim().length > 0) {
+    console.error(
+      "Git working tree is not clean. Commit or stash your changes before releasing."
+    );
+    process.exit(1);
+  }
+}
+
+async function main() {
+  const bump = getVersionBumpFromArgs();
+
+  console.log("Ensuring clean git working tree...");
+  ensureCleanGit();
+
+  console.log("\nBuilding project...");
+  run("npm", ["run", "build"]);
+
+  console.log(`\nBumping version (${bump})...`);
+  run("npm", ["version", bump]);
+
+  console.log("\nPublishing to npm...");
+  run("npm", ["publish"]);
+
+  console.log("\nRelease complete.");
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
+

package/src/resolve-imports.ts

@@ -0,0 +1,121 @@
+import path from "node:path";
+import type { ComponentsConfig } from "./components.js";
+import { extractPathSpecifiers } from "./extract-imports.js";
+import type { ScannedFile } from "./git.js";
+
+const EXTENSIONS = [".tsx", ".ts", ".jsx", ".js", ".mts", ".mjs", ".cts", ".cjs"];
+const INDEX_NAMES = ["index.tsx", "index.ts", "index.jsx", "index.js"];
+
+/** Build [aliasPrefix, pathPrefix] pairs, longest first. pathPrefix is project-relative (e.g. src/lib when isSrcDir). */
+function getAliasEntries(config: ComponentsConfig & { isSrcDir?: boolean }): [string, string][] {
+  const entries: [string, string][] = [];
+  const prefix = config.isSrcDir ? "src/" : "";
+  const keys: (keyof ComponentsConfig)[] = ["components", "utils", "ui", "lib", "hooks"];
+  for (const k of keys) {
+    const v = config[k];
+    if (typeof v === "string" && v.startsWith("@/")) {
+      const pathPart = v.replace(/^@\//, "").replace(/\/$/, "");
+      entries.push([v.replace(/\/$/, ""), prefix + pathPart]);
+    }
+  }
+  entries.push(["@", config.isSrcDir ? "src" : ""]);
+  entries.sort((a, b) => b[0].length - a[0].length);
+  return entries;
+}
+
+/**
+ * Resolve a path-like import specifier to a project-relative file path.
+ * Tries common extensions and /index.*. Returns the first path that exists in projectPaths.
+ */
+function resolveSpecifier(
+  specifier: string,
+  fromFilePath: string,
+  aliasEntries: [string, string][],
+  projectPaths: Set<string>,
+  rootFallback: string,
+): string | null {
+  const normalizedFrom = fromFilePath.replace(/\\/g, "/");
+  const fromDir = path.dirname(normalizedFrom).replace(/\\/g, "/");
+
+  let candidate: string;
+
+  if (specifier.startsWith(".") || specifier.startsWith("/")) {
+    candidate = path.normalize(path.join(fromDir, specifier)).replace(/\\/g, "/");
+  } else {
+    // Alias: @/components/Button -> components/Button
+    let matched = false;
+    for (const [aliasPrefix, pathPrefix] of aliasEntries) {
+      const prefix = aliasPrefix === "@" ? "@/" : aliasPrefix.endsWith("/") ? aliasPrefix : aliasPrefix + "/";
+      if (specifier === aliasPrefix || specifier.startsWith(prefix)) {
+        const suffix = specifier.slice(prefix.length).replace(/^\//, "");
+        candidate = path.normalize(path.join(pathPrefix, suffix)).replace(/\\/g, "/");
+        matched = true;
+        break;
+      }
+    }
+    if (!matched) {
+      const suffix = specifier.replace(/^@\//, "").replace(/^~\//, "");
+      candidate = path.normalize(path.join(rootFallback, suffix)).replace(/\\/g, "/");
+    }
+  }
+
+  if (!candidate) return null;
+  if (projectPaths.has(candidate)) return candidate;
+
+  for (const ext of EXTENSIONS) {
+    const p = candidate.endsWith(ext) ? candidate : candidate + ext;
+    if (projectPaths.has(p)) return p;
+  }
+  for (const name of INDEX_NAMES) {
+    const p = candidate.endsWith("/") ? candidate + name : candidate + "/" + name;
+    if (projectPaths.has(p)) return p;
+  }
+  return null;
+}
+
+/**
+ * Expand the list of included files by recursively adding any project file
+ * that is imported (via relative or alias path) by an already-included file.
+ * Uses TypeScript/JS import syntax only.
+ */
+export function expandIncludedFiles(
+  includedFiles: ScannedFile[],
+  allProjectFiles: ScannedFile[],
+  config: ComponentsConfig & { isSrcDir?: boolean },
+): ScannedFile[] {
+  const projectPathToFile = new Map<string, ScannedFile>();
+  for (const f of allProjectFiles) {
+    const key = f.path.replace(/\\/g, "/");
+    projectPathToFile.set(key, f);
+  }
+  const projectPaths = new Set(projectPathToFile.keys());
+  const aliasEntries = getAliasEntries(config);
+  const rootFallback = config.isSrcDir ? "src" : "";
+
+  const includedPaths = new Set<string>();
+  for (const f of includedFiles) {
+    includedPaths.add(f.path.replace(/\\/g, "/"));
+  }
+
+  let added = true;
+  while (added) {
+    added = false;
+    for (const file of [...includedFiles]) {
+      const content = file.content;
+      const fromPath = file.path.replace(/\\/g, "/");
+      for (const spec of extractPathSpecifiers(content)) {
+        const resolved = resolveSpecifier(spec, fromPath, aliasEntries, projectPaths, rootFallback);
+        if (resolved && !includedPaths.has(resolved)) {
+          const scanned = projectPathToFile.get(resolved);
+          if (scanned) {
+            includedFiles.push(scanned);
+            includedPaths.add(resolved);
+            added = true;
+          }
+        }
+      }
+    }
+  }
+
+  return includedFiles;
+}