Update for CI failures

Author: Matt-Dionis

.github/workflows/publish.yml

@@ -25,7 +25,7 @@ jobs:
       - name: Setup Node.js
         uses: actions/setup-node@v4
         with:
-          node-version: '18'
+          node-version: '20'
           registry-url: 'https://registry.npmjs.org'
 
       - name: Cache dependencies

.github/workflows/test.yml

@@ -12,7 +12,7 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [16, 18, 20]
+        node-version: [18.x, 20.x]
 
     defaults:
       run:
@@ -82,7 +82,7 @@ jobs:
       - name: Setup Node.js
         uses: actions/setup-node@v4
         with:
-          node-version: '18'
+          node-version: '20'
 
       - name: Install dependencies
         run: npm ci

claude-config-composer/biome.json

@@ -36,6 +36,7 @@
         "noConfusingVoidType": "error",
         "noConsole": "off",
         "noEmptyBlockStatements": "error",
+        "noControlCharactersInRegex": "off",
         "useIterableCallbackReturn": "off"
       },
       "complexity": {

claude-config-composer/src/cli/commands/generate.ts

@@ -129,11 +129,8 @@ export class GenerateCommand {
 
       // Validate output directory if provided
       if (options.output) {
-        // For absolute paths (like in tests), just check they exist or can be created
-        // For relative paths, validate them properly
-        if (!path.isAbsolute(options.output)) {
-          PathValidator.validatePath(options.output);
-        }
+        // Validate output path (allows absolute paths)
+        PathValidator.validateOutputPath(options.output);
       }
     } catch (error) {
       if (error instanceof ValidationError) {
@@ -173,7 +170,7 @@ export class GenerateCommand {
     // If explicit output is provided, validate and use it
     if (options.output) {
       try {
-        return PathValidator.validatePath(options.output);
+        return PathValidator.validateOutputPath(options.output);
       } catch (error) {
         throw new ValidationError(
           `Invalid output directory: ${error instanceof PathValidationError ? error.message : 'Unknown error'}`,
@@ -186,7 +183,7 @@ export class GenerateCommand {
     if (await GenerateCommand.isClaudeConfigRepo()) {
       const configName = configs.join('-');
       const testPath = path.join('.test-output', configName);
-      return PathValidator.validatePath(testPath);
+      return PathValidator.validateOutputPath(testPath);
     }
 
     // Default: output to current directory (production use)
@@ -220,7 +217,7 @@ export class GenerateCommand {
       }
 
       // Validate the directory path before creating
-      const validatedPath = PathValidator.validatePath(dirPath);
+      const validatedPath = PathValidator.validateOutputPath(dirPath);
       if (validatedPath) {
         await fs.mkdir(validatedPath, { recursive: true });
       }

claude-config-composer/src/generator/config-generator.ts

@@ -26,15 +26,30 @@ export class ConfigGenerator {
     showProgress: boolean = true
   ): Promise<void> {
     // Handle output directory path
-    // Always normalize the path, whether absolute or relative
-    // This avoids the need for process.cwd() which can fail in CI
-    if (!outputDir) {
-      outputDir = '.';
+    // Resolve to absolute path immediately while we can
+    // This prevents issues when the current directory is deleted during execution
+    let resolvedOutputDir = outputDir || '.';
+
+    // Resolve to absolute path early, before any async operations
+    // Use a try-catch in case process.cwd() fails
+    let absoluteOutputDir: string;
+    try {
+      absoluteOutputDir = path.resolve(resolvedOutputDir);
+    } catch {
+      // If we can't resolve (e.g., cwd deleted), use the path as-is if absolute
+      // or throw a clear error if it's relative
+      if (path.isAbsolute(resolvedOutputDir)) {
+        absoluteOutputDir = path.normalize(resolvedOutputDir);
+      } else {
+        throw new Error(
+          `Cannot resolve relative path '${resolvedOutputDir}' - current directory may not exist. ` +
+            'Please provide an absolute path or ensure the current directory is valid.'
+        );
+      }
     }
 
-    // Normalize the path - this works for both absolute and relative paths
-    // and doesn't require process.cwd()
-    outputDir = path.normalize(outputDir);
+    // Use absoluteOutputDir from here on
+    resolvedOutputDir = absoluteOutputDir;
 
     // Validate input configurations
     try {
@@ -79,34 +94,15 @@ export class ConfigGenerator {
       if (spinner) spinner.start(steps[currentStep]);
 
       // Create directories
-      // For absolute outputDir paths, join directly
-      // For relative paths, createSafeDirectory handles validation
-      let claudeDir: string;
-      let agentsDir: string;
-      let commandsDir: string;
-      let hooksDir: string;
-
-      if (path.isAbsolute(outputDir)) {
-        // For absolute paths (e.g., test temp directories), join directly
-        claudeDir = path.join(outputDir, '.claude');
-        agentsDir = path.join(outputDir, '.claude', 'agents');
-        commandsDir = path.join(outputDir, '.claude', 'commands');
-        hooksDir = path.join(outputDir, '.claude', 'hooks');
-      } else {
-        // For relative paths, construct the full paths
-        claudeDir = path.join(outputDir, '.claude');
-        agentsDir = path.join(outputDir, '.claude', 'agents');
-        commandsDir = path.join(outputDir, '.claude', 'commands');
-        hooksDir = path.join(outputDir, '.claude', 'hooks');
-      }
-      
-      // Create all directories
-      await fs.mkdir(claudeDir, { recursive: true });
-      await fs.mkdir(agentsDir, { recursive: true });
-      await fs.mkdir(commandsDir, { recursive: true });
-      await fs.mkdir(hooksDir, { recursive: true });
-
-      await fs.mkdir(outputDir, { recursive: true });
+      // Since resolvedOutputDir is now always absolute, we can safely join paths
+      const claudeDir = path.join(resolvedOutputDir, '.claude');
+      const agentsDir = path.join(claudeDir, 'agents');
+      const commandsDir = path.join(claudeDir, 'commands');
+      const hooksDir = path.join(claudeDir, 'hooks');
+
+      // Create all directories with absolute paths
+      // Create parent directory first to ensure it exists
+      await fs.mkdir(resolvedOutputDir, { recursive: true });
       await fs.mkdir(claudeDir, { recursive: true });
       await fs.mkdir(agentsDir, { recursive: true });
       await fs.mkdir(commandsDir, { recursive: true });
@@ -126,8 +122,8 @@ export class ConfigGenerator {
 
       if (claudeMdConfigs.length > 0) {
         const mergedClaudeMd = this.configMerger.merge(claudeMdConfigs);
-        // Write directly to outputDir without additional path validation since outputDir is already validated
-        const claudeMdPath = path.join(outputDir, 'CLAUDE.md');
+        // Write directly to resolvedOutputDir without additional path validation since resolvedOutputDir is already validated
+        const claudeMdPath = path.join(resolvedOutputDir, 'CLAUDE.md');
         await fs.writeFile(claudeMdPath, mergedClaudeMd);
       }
       if (spinner) spinner.succeed(steps[currentStep]);
@@ -144,9 +140,7 @@ export class ConfigGenerator {
         const agentName = typeof validatedAgent.name === 'string' ? validatedAgent.name : 'unknown';
         const filename = `${PathValidator.validateFilename(agentName.toLowerCase().replace(/[^a-z0-9-]/g, '-'))}.md`;
         const content = this.componentMerger.generateAgentFile(validatedAgent);
-        // Ensure directory exists before writing
-        await fs.mkdir(agentsDir, { recursive: true });
-        // Write directly to agentsDir
+        // Write directly to agentsDir (already created above)
         const agentPath = path.join(agentsDir, filename);
         await fs.writeFile(agentPath, content);
       }
@@ -166,9 +160,7 @@ export class ConfigGenerator {
           typeof validatedCommand.name === 'string' ? validatedCommand.name : 'unknown';
         const filename = `${PathValidator.validateFilename(commandName.toLowerCase().replace(/[^a-z0-9-]/g, '-'))}.md`;
         const content = this.componentMerger.generateCommandFile(validatedCommand);
-        // Ensure directory exists before writing
-        await fs.mkdir(commandsDir, { recursive: true });
-        // Write directly to commandsDir
+        // Write directly to commandsDir (already created above)
         const commandPath = path.join(commandsDir, filename);
         await fs.writeFile(commandPath, content);
       }
@@ -181,8 +173,7 @@ export class ConfigGenerator {
       const hookGroups = parsedConfigs.map(c => c.parsed.hooks);
       const mergedHooks = this.componentMerger.mergeHooks(hookGroups);
 
-      // Ensure hooks directory exists
-      await fs.mkdir(hooksDir, { recursive: true });
+      // Process hooks (directory already created above)
       for (const hook of mergedHooks) {
         // Validate and sanitize hook data
         const validatedHook = InputValidator.validateHook(hook);
@@ -221,7 +212,7 @@ export class ConfigGenerator {
       const settingsPath = await PathValidator.createSafeFilePath(
         'settings.json',
         '.claude',
-        outputDir
+        resolvedOutputDir
       );
 
       await fs.writeFile(settingsPath, JSON.stringify(validatedSettings, null, 2));
@@ -232,7 +223,7 @@ export class ConfigGenerator {
       // Validate the generated structure
       currentStep++;
       if (spinner) spinner.start(steps[currentStep]);
-      const validation = await this.validateGeneratedStructure(outputDir);
+      const validation = await this.validateGeneratedStructure(resolvedOutputDir);
       if (!validation.valid) {
         if (spinner) spinner.warn(`${steps[currentStep]} - ${validation.errors.length} warnings`);
         validation.errors.forEach(error => console.warn(chalk.yellow(`   - ${error}`)));

claude-config-composer/src/merger/component-merger.ts

@@ -274,30 +274,38 @@ export class ComponentMerger {
     return merged;
   }
 
-  private isValidHookEntry(entry: any): boolean {
-    return entry && typeof entry === 'object' && 'hooks' in entry && Array.isArray(entry.hooks);
+  private isValidHookEntry(entry: unknown): boolean {
+    return (
+      entry !== null &&
+      typeof entry === 'object' &&
+      'hooks' in entry &&
+      Array.isArray((entry as { hooks: unknown }).hooks)
+    );
   }
 
-  private normalizeHookEntry(entry: any): HookEntry {
+  private normalizeHookEntry(entry: unknown): HookEntry {
     const normalized: HookEntry = {
       hooks: [],
     };
 
+    const entryObj = entry as Record<string, unknown>;
+
     // Only include matcher if it exists and is not empty
-    if (entry.matcher && entry.matcher !== '') {
-      normalized.matcher = entry.matcher;
+    if (entryObj.matcher && entryObj.matcher !== '') {
+      normalized.matcher = entryObj.matcher as string;
     }
 
     // Process hooks array
-    if (Array.isArray(entry.hooks)) {
-      for (const hook of entry.hooks) {
+    if (Array.isArray(entryObj.hooks)) {
+      for (const hook of entryObj.hooks) {
         if (hook && typeof hook === 'object' && 'command' in hook) {
+          const hookObj = hook as Record<string, unknown>;
           const hookCommand: HookCommand = {
-            type: hook.type || 'command',
-            command: hook.command,
+            type: 'command',
+            command: hookObj.command as string,
           };
-          if (hook.timeout) {
-            hookCommand.timeout = hook.timeout;
+          if (hookObj.timeout) {
+            hookCommand.timeout = hookObj.timeout as number;
           }
           normalized.hooks.push(hookCommand);
         }

claude-config-composer/src/merger/config-merger.ts

@@ -1,4 +1,5 @@
 import type { ConfigMetadata } from '../registry/config-registry';
+import type { PackageDependencies } from '../types/config';
 import { ConfigurationError, ErrorHandler, ValidationError } from '../utils/error-handler';
 
 interface Section {
@@ -164,7 +165,13 @@ export class ConfigMerger {
       .trim();
   }
 
-  merge(configs: Array<{ content: string; metadata: ConfigMetadata; dependencies?: any }>): string {
+  merge(
+    configs: Array<{
+      content: string;
+      metadata: ConfigMetadata;
+      dependencies?: PackageDependencies;
+    }>
+  ): string {
     return ErrorHandler.wrapSync(() => {
       // Validate inputs
       if (!configs || !Array.isArray(configs)) {
@@ -637,7 +644,7 @@ export class ConfigMerger {
 
   private addMetadata(
     output: string[],
-    configs: Array<{ metadata: ConfigMetadata; dependencies?: any }>
+    configs: Array<{ metadata: ConfigMetadata; dependencies?: PackageDependencies }>
   ) {
     output.push('');
     output.push('---');
@@ -662,7 +669,7 @@ export class ConfigMerger {
       const allPeerDeps = new Map<string, Set<string>>();
       const allEngines = new Map<string, Set<string>>();
 
-      for (const { metadata, dependencies } of configsWithDeps) {
+      for (const { dependencies } of configsWithDeps) {
         if (dependencies?.peerDependencies) {
           for (const [pkg, version] of Object.entries(dependencies.peerDependencies)) {
             if (!allPeerDeps.has(pkg)) allPeerDeps.set(pkg, new Set());

claude-config-composer/src/parser/config-parser.ts

@@ -154,7 +154,7 @@ export class ConfigParser {
       const hooks: Hook[] = [];
       let settings: Settings | null = null;
       let claudeMd: string | null = null;
-      let dependencies: any;
+      let dependencies: Record<string, string> | undefined;
 
       // Validate config path
       if (!configPath || typeof configPath !== 'string') {
@@ -403,7 +403,7 @@ export class ConfigParser {
       if (frontmatterEnd > 0) {
         const frontmatter = lines.slice(1, frontmatterEnd).join('\n');
         try {
-          metadata = yaml.load(frontmatter) as any;
+          metadata = yaml.load(frontmatter) as Record<string, unknown>;
           if (!metadata || typeof metadata !== 'object') {
             metadata = {};
           }
@@ -489,7 +489,7 @@ export class ConfigParser {
       if (frontmatterEnd > 0) {
         const frontmatter = lines.slice(1, frontmatterEnd).join('\n');
         try {
-          metadata = yaml.load(frontmatter) as any;
+          metadata = yaml.load(frontmatter) as Record<string, unknown>;
           if (!metadata || typeof metadata !== 'object') {
             metadata = {};
           }

claude-config-composer/src/types/config.ts

@@ -87,6 +87,14 @@ export interface ConfigComponent {
   metadata?: ConfigMetadata;
 }
 
+export interface PackageDependencies {
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  peerDependencies?: Record<string, string>;
+  optionalDependencies?: Record<string, string>;
+  engines?: Record<string, string>;
+}
+
 export interface ConfigMetadata {
   title?: string;
   description?: string;

claude-config-composer/src/ui/cli-visuals.ts

@@ -110,7 +110,11 @@ export function createLoadingBar(title: string) {
     let gradientTitle: string;
     if (gradient && typeof gradient === 'function') {
       try {
-        const gradientFn = (gradient as any)(['#EB6359', '#E2DDD9', '#1F1F25']);
+        const gradientFn = (gradient as unknown as (colors: string[]) => (text: string) => string)([
+          '#EB6359',
+          '#E2DDD9',
+          '#1F1F25',
+        ]);
         gradientTitle = gradientFn(title);
       } catch {
         gradientTitle = chalk.hex('#EB6359')(title);
@@ -135,7 +139,10 @@ export function showLivePreview(configs: string[]) {
   let title: string;
   if (gradient && typeof gradient === 'function') {
     try {
-      const gradientFn = (gradient as any)(['#EB6359', '#E2DDD9']);
+      const gradientFn = (gradient as unknown as (colors: string[]) => (text: string) => string)([
+        '#EB6359',
+        '#E2DDD9',
+      ]);
       title = gradientFn('LIVE PREVIEW - Your Configuration Blueprint');
     } catch {
       title = chalk.hex('#EB6359')('LIVE PREVIEW - Your Configuration Blueprint');