@nexical/cli 0.11.0 → 0.11.1

package/src/utils/discovery.ts

@@ -4,131 +4,116 @@ import fs from 'node:fs';
 
 /**
  * Discovers command directories to load into the CLI.
- * 
+ *
  * Scans for:
  * 1. Core commands (projectRoot/src/commands)
  * 2. Module commands (projectRoot/src/modules/ * /src/commands)
- * 
+ *
  * @param projectRoot - The root directory of the project
  * @returns Array of absolute paths to command directories
  */
 export function discoverCommandDirectories(projectRoot: string): string[] {
-    const directories: string[] = [];
-    const visited = new Set<string>();
-
-    const addDir = (dir: string) => {
-        const resolved = path.resolve(dir);
-        if (visited.has(resolved)) return;
-
-        if (fs.existsSync(resolved)) {
-            // Check if we already have a similar path (e.g. dist/src/commands vs src/commands)
-            // If we are adding src/commands and dist/src/commands already exists in visited, skip it
-            // and vice versa.
-            const isSrc = resolved.endsWith(path.join('src', 'commands'));
-            const isDist = resolved.includes(path.join('dist', 'src', 'commands')) ||
-                resolved.endsWith(path.join('dist', 'commands'));
-
-            if (isSrc) {
-                const distEquivalent1 = resolved.replace(path.sep + 'src' + path.sep, path.sep + 'dist' + path.sep + 'src' + path.sep);
-                const distEquivalent2 = resolved.replace(path.sep + 'src' + path.sep, path.sep + 'dist' + path.sep);
-                if (visited.has(distEquivalent1) || visited.has(distEquivalent2)) {
-                    logger.debug(`Skipping ${resolved} because a dist version is already registered`);
-                    return;
-                }
-            }
+  const directories: string[] = [];
+  const visited = new Set<string>();
+
+  const isTsEnvironment =
+    process.argv[1]?.endsWith('.ts') ||
+    process.argv[1]?.endsWith('.mts') ||
+    process.execArgv.some(
+      (arg) => arg.includes('tsx') || arg.includes('ts-node') || arg.includes('vitest'),
+    ) ||
+    process.env.VITEST === 'true' ||
+    process.env.NODE_ENV === 'test';
+
+  const addDir = (dir: string) => {
+    const resolved = path.resolve(dir);
+    if (!fs.existsSync(resolved)) {
+      logger.debug(`Command directory not found (skipping): ${resolved}`);
+      return;
+    }
 
-            if (isDist) {
-                const srcEquivalent1 = resolved.replace(path.sep + 'dist' + path.sep, path.sep);
-                const srcEquivalent2 = resolved.replace(path.sep + 'dist' + path.sep + 'src' + path.sep, path.sep + 'src' + path.sep);
-                if (visited.has(srcEquivalent1) || visited.has(srcEquivalent2)) {
-                    // If we just added src, and now we find dist, we should actually REPLACE src with dist
-                    // but for now, the loop order prefers dist, so this case shouldn't happen much.
-                    // However, let's keep it simple.
-                    logger.debug(`Skipping ${resolved} because a src version is already registered`);
-                    return;
-                }
-            }
+    if (visited.has(resolved)) return;
+
+    // Detect if this is a source command directory
+    const srcPattern = path.join(path.sep, 'src', 'commands');
+    const distPattern = path.join(path.sep, 'dist');
+    const isSrcDir = resolved.endsWith(srcPattern) && !resolved.includes(distPattern);
+
+    // Strict check: if we are adding a 'src' directory...
+    if (isSrcDir) {
+      // 1. Check if an equivalent 'dist' exists in the same package
+      const distPath1 = resolved.replace(
+        srcPattern,
+        path.join(path.sep, 'dist', 'src', 'commands'),
+      );
+      const distPath2 = resolved.replace(srcPattern, path.join(path.sep, 'dist', 'commands'));
+
+      if (fs.existsSync(distPath1) || fs.existsSync(distPath2)) {
+        logger.debug(`Skipping src commands at ${resolved} because dist exists`);
+        return;
+      }
+
+      // 2. If no TS loader, skip src/commands entirely IF it's likely to contain .ts
+      if (!isTsEnvironment) {
+        logger.debug(`Skipping src commands at ${resolved}: no TS loader detected`);
+        return;
+      }
+    }
 
-            logger.debug(`Found command directory: ${resolved}`);
-            directories.push(resolved);
-            visited.add(resolved);
-        } else {
-            logger.debug(`Command directory not found (skipping): ${resolved}`);
-        }
-    };
-
-    // 1. Core commands
-    // Search in projectRoot
-    const possibleCorePaths = [
-        path.join(projectRoot, 'src/commands'),
-    ];
-
-    possibleCorePaths.forEach(addDir);
-
-    // 2. Module commands
-    const possibleModuleDirs = [
-        path.join(projectRoot, 'modules'),
-        path.join(projectRoot, 'src', 'modules') // Support both flat and src-nested
-    ];
-
-    possibleModuleDirs.forEach(modulesDir => {
-        if (fs.existsSync(modulesDir)) {
-            try {
-                const modules = fs.readdirSync(modulesDir);
-                for (const mod of modules) {
-                    // exclude system files/dirs like .keep
-                    if (mod.startsWith('.')) continue;
-
-                    const modPath = path.join(modulesDir, mod);
-                    if (!fs.statSync(modPath).isDirectory()) continue;
-
-                    // Check for commands inside the module/package
-                    // Order matters: prefer dist if it exists
-                    const possibleCmdPaths = [
-                        path.join(modPath, 'dist/src/commands'),
-                        path.join(modPath, 'dist/commands'),
-                        path.join(modPath, 'src/commands')
-                    ];
-
-                    for (const cmdPath of possibleCmdPaths) {
-                        if (fs.existsSync(cmdPath) && fs.statSync(cmdPath).isDirectory()) {
-                            addDir(cmdPath);
-                        }
-                    }
-                }
-            } catch (e: any) {
-                logger.debug(`Error scanning modules directory ${modulesDir}: ${e.message}`);
+    logger.debug(`Found command directory: ${resolved}`);
+    directories.push(resolved);
+    visited.add(resolved);
+  };
+
+  // 1. Core commands
+  const possibleCorePaths = [path.join(projectRoot, 'src/commands')];
+  possibleCorePaths.forEach(addDir);
+
+  // 2. Module & Package commands
+  const searchRoots = [
+    path.join(projectRoot, 'modules'),
+    path.join(projectRoot, 'src', 'modules'),
+    path.join(projectRoot, 'packages'),
+  ];
+
+  searchRoots.forEach((root) => {
+    if (!fs.existsSync(root)) return;
+    try {
+      const entries = fs.readdirSync(root);
+      for (const entry of entries) {
+        if (entry.startsWith('.')) continue;
+        const entryPath = path.join(root, entry);
+        if (!fs.statSync(entryPath).isDirectory()) continue;
+
+        // Preference: dist/src/commands > dist/commands > src/commands
+        const possiblePaths = [
+          path.join(entryPath, 'dist/src/commands'),
+          path.join(entryPath, 'dist/commands'),
+          path.join(entryPath, 'src/commands'),
+        ];
+
+        let foundDist = false;
+        for (const p of possiblePaths) {
+          if (fs.existsSync(p) && fs.statSync(p).isDirectory()) {
+            if (p.includes(path.sep + 'dist' + path.sep)) {
+              addDir(p);
+              foundDist = true;
+              break; // Found a dist version, skip others for this entry
             }
+          }
         }
-    });
-
-    // 3. Package commands (e.g. packages/*)
-    const packagesDir = path.join(projectRoot, 'packages');
-    if (fs.existsSync(packagesDir)) {
-        try {
-            const packages = fs.readdirSync(packagesDir);
-            for (const pkg of packages) {
-                if (pkg.startsWith('.')) continue;
-
-                const pkgPath = path.join(packagesDir, pkg);
-                if (!fs.statSync(pkgPath).isDirectory()) continue;
-
-                const possibleCmdPaths = [
-                    path.join(pkgPath, 'dist/src/commands'),
-                    path.join(pkgPath, 'dist/commands'),
-                    path.join(pkgPath, 'src/commands')
-                ];
-
-                for (const cmdPath of possibleCmdPaths) {
-                    if (fs.existsSync(cmdPath) && fs.statSync(cmdPath).isDirectory()) {
-                        addDir(cmdPath);
-                    }
-                }
-            }
-        } catch (e: any) {
-            logger.debug(`Error scanning packages directory: ${e.message}`);
+
+        if (!foundDist) {
+          const srcPath = path.join(entryPath, 'src/commands');
+          if (fs.existsSync(srcPath) && fs.statSync(srcPath).isDirectory()) {
+            addDir(srcPath);
+          }
         }
+      }
+    } catch (e: unknown) {
+      logger.debug(`Error scanning root ${root}: ${e instanceof Error ? e.message : String(e)}`);
     }
+  });
 
-    return directories;
+  return directories;
 }

package/src/utils/git.ts

@@ -4,62 +4,69 @@ import { promisify } from 'node:util';
 
 const execAsync = promisify(exec);
 
-export async function clone(url: string, destination: string, options: { recursive?: boolean; depth?: number } = {}): Promise<void> {
-    const { recursive = false, depth } = options;
-    const cmd = `git clone ${recursive ? '--recursive ' : ''}${depth ? `--depth ${depth} ` : ''}${url} .`;
-    logger.debug(`Git clone: ${url} to ${destination}`);
-    await runCommand(cmd, destination);
+export async function clone(
+  url: string,
+  destination: string,
+  options: { recursive?: boolean; depth?: number } = {},
+): Promise<void> {
+  const { recursive = false, depth } = options;
+  const cmd = `git clone ${recursive ? '--recursive ' : ''}${depth ? `--depth ${depth} ` : ''}${url} .`;
+  logger.debug(`Git clone: ${url} to ${destination}`);
+  await runCommand(cmd, destination);
 }
 
 export async function getRemoteUrl(cwd: string, remote = 'origin'): Promise<string> {
-    try {
-        const { stdout } = await execAsync(`git remote get-url ${remote}`, { cwd });
-        return stdout.trim();
-    } catch (e) {
-        console.error('getRemoteUrl failed:', e);
-        return '';
-    }
+  try {
+    const { stdout } = await execAsync(`git remote get-url ${remote}`, { cwd });
+    return stdout.trim();
+  } catch (e) {
+    console.error('getRemoteUrl failed:', e);
+    return '';
+  }
 }
 
 export async function updateSubmodules(cwd: string): Promise<void> {
-    logger.debug(`Updating submodules in ${cwd}`);
-    await runCommand('git submodule foreach --recursive "git checkout main && git pull origin main"', cwd);
+  logger.debug(`Updating submodules in ${cwd}`);
+  await runCommand(
+    'git submodule foreach --recursive "git checkout main && git pull origin main"',
+    cwd,
+  );
 }
 
 export async function checkoutOrphan(branch: string, cwd: string): Promise<void> {
-    await runCommand(`git checkout --orphan ${branch}`, cwd);
+  await runCommand(`git checkout --orphan ${branch}`, cwd);
 }
 
 export async function addAll(cwd: string): Promise<void> {
-    await runCommand('git add -A', cwd);
+  await runCommand('git add -A', cwd);
 }
 
 export async function commit(message: string, cwd: string): Promise<void> {
-    // Escape quotes in message if needed, for now assuming simple messages
-    await runCommand(`git commit -m "${message}"`, cwd);
+  // Escape quotes in message if needed, for now assuming simple messages
+  await runCommand(`git commit -m "${message}"`, cwd);
 }
 
 export async function deleteBranch(branch: string, cwd: string): Promise<void> {
-    await runCommand(`git branch -D ${branch}`, cwd);
+  await runCommand(`git branch -D ${branch}`, cwd);
 }
 
 export async function renameBranch(branch: string, cwd: string): Promise<void> {
-    await runCommand(`git branch -m ${branch}`, cwd);
+  await runCommand(`git branch -m ${branch}`, cwd);
 }
 
 export async function removeRemote(remote: string, cwd: string): Promise<void> {
-    await runCommand(`git remote remove ${remote}`, cwd);
+  await runCommand(`git remote remove ${remote}`, cwd);
 }
 
 export async function renameRemote(oldName: string, newName: string, cwd: string): Promise<void> {
-    await runCommand(`git remote rename ${oldName} ${newName}`, cwd);
+  await runCommand(`git remote rename ${oldName} ${newName}`, cwd);
 }
 
 export async function branchExists(branch: string, cwd: string): Promise<boolean> {
-    try {
-        await execAsync(`git show-ref --verify --quiet refs/heads/${branch}`, { cwd });
-        return true;
-    } catch {
-        return false;
-    }
+  try {
+    await execAsync(`git show-ref --verify --quiet refs/heads/${branch}`, { cwd });
+    return true;
+  } catch {
+    return false;
+  }
 }

package/src/utils/url-resolver.ts

@@ -1,57 +1,62 @@
 /**
  * Resolves a git URL from various shorthand formats.
- * 
+ *
  * Supported formats:
  * - gh@org/repo -> https://github.com/org/repo.git
  * - gh@org/repo//path -> https://github.com/org/repo.git//path
  * - https://github.com/org/repo -> https://github.com/org/repo.git
  * - https://github.com/org/repo.git -> https://github.com/org/repo.git
- * 
+ *
  * @param url The URL string to resolve
  * @returns The fully qualified git URL with .git extension
  */
 export function resolveGitUrl(url: string): string {
-    if (!url) {
-        throw new Error('URL cannot be empty');
-    }
-
-    let resolved = url;
-
-    // Handle gh@ syntax
-    if (resolved.startsWith('gh@')) {
-        resolved = resolved.replace(/^gh@/, 'https://github.com/');
-    }
-
-    // Handle subpaths (split by //)
-    // We must be careful not to split the protocol (e.g. https://)
-    const protocolMatch = resolved.match(/^[a-z0-9]+:\/\//i);
-    let splitIndex = -1;
-
-    if (protocolMatch) {
-        splitIndex = resolved.indexOf('//', protocolMatch[0].length);
-    } else {
-        splitIndex = resolved.indexOf('//');
-    }
-
-    let repoUrl = resolved;
-    let subPath = '';
-
-    if (splitIndex !== -1) {
-        repoUrl = resolved.substring(0, splitIndex);
-        subPath = resolved.substring(splitIndex + 2);
-    }
-
-    // Ensure .git extension, but ONLY for remote URLs (not local paths)
-    const isLocal = repoUrl.startsWith('/') || repoUrl.startsWith('./') || repoUrl.startsWith('../') || repoUrl.startsWith('file:') || repoUrl.startsWith('~');
-
-    if (!isLocal && !repoUrl.endsWith('.git')) {
-        repoUrl += '.git';
-    }
-
-    // Reconstruction
-    if (subPath) {
-        return `${repoUrl}//${subPath}`;
-    }
-
-    return repoUrl;
+  if (!url) {
+    throw new Error('URL cannot be empty');
+  }
+
+  let resolved = url;
+
+  // Handle gh@ syntax
+  if (resolved.startsWith('gh@')) {
+    resolved = resolved.replace(/^gh@/, 'https://github.com/');
+  }
+
+  // Handle subpaths (split by //)
+  // We must be careful not to split the protocol (e.g. https://)
+  const protocolMatch = resolved.match(/^[a-z0-9]+:\/\//i);
+  let splitIndex = -1;
+
+  if (protocolMatch) {
+    splitIndex = resolved.indexOf('//', protocolMatch[0].length);
+  } else {
+    splitIndex = resolved.indexOf('//');
+  }
+
+  let repoUrl = resolved;
+  let subPath = '';
+
+  if (splitIndex !== -1) {
+    repoUrl = resolved.substring(0, splitIndex);
+    subPath = resolved.substring(splitIndex + 2);
+  }
+
+  // Ensure .git extension, but ONLY for remote URLs (not local paths)
+  const isLocal =
+    repoUrl.startsWith('/') ||
+    repoUrl.startsWith('./') ||
+    repoUrl.startsWith('../') ||
+    repoUrl.startsWith('file:') ||
+    repoUrl.startsWith('~');
+
+  if (!isLocal && !repoUrl.endsWith('.git')) {
+    repoUrl += '.git';
+  }
+
+  // Reconstruction
+  if (subPath) {
+    return `${repoUrl}//${subPath}`;
+  }
+
+  return repoUrl;
 }