@aiready/core 0.23.2 → 0.23.3

package/dist/utils/ast-parser.js

@@ -3,214 +3,211 @@ import { parse } from '@typescript-eslint/typescript-estree';
  * Parse TypeScript/JavaScript file and extract exports with their import dependencies
  */
 export function parseFileExports(code, filePath) {
-    try {
-        const ast = parse(code, {
-            loc: true,
-            range: true,
-            jsx: filePath.endsWith('.tsx') || filePath.endsWith('.jsx'),
-            filePath,
-        });
-        const imports = extractFileImports(ast);
-        const exports = extractExportsWithDependencies(ast, imports);
-        return { exports, imports };
-    }
-    catch (error) {
-        // Fallback to empty if parsing fails
-        return { exports: [], imports: [] };
-    }
+  try {
+    const ast = parse(code, {
+      loc: true,
+      range: true,
+      jsx: filePath.endsWith('.tsx') || filePath.endsWith('.jsx'),
+      filePath,
+    });
+    const imports = extractFileImports(ast);
+    const exports = extractExportsWithDependencies(ast, imports);
+    return { exports, imports };
+  } catch (error) {
+    // Fallback to empty if parsing fails
+    return { exports: [], imports: [] };
+  }
 }
 /**
  * Extract all imports from the file
  */
 function extractFileImports(ast) {
-    const imports = [];
-    for (const node of ast.body) {
-        if (node.type === 'ImportDeclaration') {
-            const source = node.source.value;
-            const specifiers = [];
-            const isTypeOnly = node.importKind === 'type';
-            for (const spec of node.specifiers) {
-                if (spec.type === 'ImportSpecifier') {
-                    const imported = spec.imported;
-                    const importName = imported.type === 'Identifier' ? imported.name : imported.value;
-                    specifiers.push(importName);
-                }
-                else if (spec.type === 'ImportDefaultSpecifier') {
-                    specifiers.push('default');
-                }
-                else if (spec.type === 'ImportNamespaceSpecifier') {
-                    specifiers.push('*');
-                }
-            }
-            imports.push({ source, specifiers, isTypeOnly });
+  const imports = [];
+  for (const node of ast.body) {
+    if (node.type === 'ImportDeclaration') {
+      const source = node.source.value;
+      const specifiers = [];
+      const isTypeOnly = node.importKind === 'type';
+      for (const spec of node.specifiers) {
+        if (spec.type === 'ImportSpecifier') {
+          const imported = spec.imported;
+          const importName =
+            imported.type === 'Identifier' ? imported.name : imported.value;
+          specifiers.push(importName);
+        } else if (spec.type === 'ImportDefaultSpecifier') {
+          specifiers.push('default');
+        } else if (spec.type === 'ImportNamespaceSpecifier') {
+          specifiers.push('*');
         }
+      }
+      imports.push({ source, specifiers, isTypeOnly });
     }
-    return imports;
+  }
+  return imports;
 }
 /**
  * Extract exports and their import dependencies
  */
 function extractExportsWithDependencies(ast, fileImports) {
-    const exports = [];
-    const importedNames = new Set(fileImports.flatMap(imp => imp.specifiers));
-    for (const node of ast.body) {
-        if (node.type === 'ExportNamedDeclaration') {
-            if (node.declaration) {
-                const exportNodes = extractFromDeclaration(node.declaration);
-                for (const exp of exportNodes) {
-                    const usedImports = findUsedImports(node.declaration, importedNames);
-                    const typeReferences = extractTypeReferences(node.declaration);
-                    exports.push({
-                        ...exp,
-                        imports: usedImports,
-                        dependencies: [],
-                        typeReferences,
-                        loc: node.loc,
-                    });
-                }
-            }
-        }
-        else if (node.type === 'ExportDefaultDeclaration') {
-            const usedImports = findUsedImports(node.declaration, importedNames);
-            const typeReferences = extractTypeReferences(node.declaration);
-            exports.push({
-                name: 'default',
-                type: 'default',
-                imports: usedImports,
-                dependencies: [],
-                typeReferences,
-                loc: node.loc,
-            });
+  const exports = [];
+  const importedNames = new Set(fileImports.flatMap((imp) => imp.specifiers));
+  for (const node of ast.body) {
+    if (node.type === 'ExportNamedDeclaration') {
+      if (node.declaration) {
+        const exportNodes = extractFromDeclaration(node.declaration);
+        for (const exp of exportNodes) {
+          const usedImports = findUsedImports(node.declaration, importedNames);
+          const typeReferences = extractTypeReferences(node.declaration);
+          exports.push({
+            ...exp,
+            imports: usedImports,
+            dependencies: [],
+            typeReferences,
+            loc: node.loc,
+          });
         }
+      }
+    } else if (node.type === 'ExportDefaultDeclaration') {
+      const usedImports = findUsedImports(node.declaration, importedNames);
+      const typeReferences = extractTypeReferences(node.declaration);
+      exports.push({
+        name: 'default',
+        type: 'default',
+        imports: usedImports,
+        dependencies: [],
+        typeReferences,
+        loc: node.loc,
+      });
     }
-    return exports;
+  }
+  return exports;
 }
 /**
  * Extract export information from a declaration
  */
 function extractFromDeclaration(declaration) {
-    const results = [];
-    if (declaration.type === 'FunctionDeclaration' && 'id' in declaration && declaration.id) {
-        results.push({ name: declaration.id.name, type: 'function' });
-    }
-    else if (declaration.type === 'ClassDeclaration' && 'id' in declaration && declaration.id) {
-        results.push({ name: declaration.id.name, type: 'class' });
-    }
-    else if (declaration.type === 'VariableDeclaration') {
-        for (const declarator of declaration.declarations) {
-            if (declarator.id.type === 'Identifier') {
-                results.push({ name: declarator.id.name, type: 'const' });
-            }
-        }
-    }
-    else if (declaration.type === 'TSTypeAliasDeclaration') {
-        results.push({ name: declaration.id.name, type: 'type' });
-    }
-    else if (declaration.type === 'TSInterfaceDeclaration') {
-        results.push({ name: declaration.id.name, type: 'interface' });
+  const results = [];
+  if (
+    declaration.type === 'FunctionDeclaration' &&
+    'id' in declaration &&
+    declaration.id
+  ) {
+    results.push({ name: declaration.id.name, type: 'function' });
+  } else if (
+    declaration.type === 'ClassDeclaration' &&
+    'id' in declaration &&
+    declaration.id
+  ) {
+    results.push({ name: declaration.id.name, type: 'class' });
+  } else if (declaration.type === 'VariableDeclaration') {
+    for (const declarator of declaration.declarations) {
+      if (declarator.id.type === 'Identifier') {
+        results.push({ name: declarator.id.name, type: 'const' });
+      }
     }
-    return results;
+  } else if (declaration.type === 'TSTypeAliasDeclaration') {
+    results.push({ name: declaration.id.name, type: 'type' });
+  } else if (declaration.type === 'TSInterfaceDeclaration') {
+    results.push({ name: declaration.id.name, type: 'interface' });
+  }
+  return results;
 }
 /**
  * Find which imports are used within a node
  */
 function findUsedImports(node, importedNames) {
-    const usedImports = new Set();
-    function visit(n) {
-        if (n.type === 'Identifier' && importedNames.has(n.name)) {
-            usedImports.add(n.name);
-        }
-        // Recursively visit child nodes
-        for (const key in n) {
-            const value = n[key];
-            if (value && typeof value === 'object') {
-                if (Array.isArray(value)) {
-                    value.forEach(child => {
-                        if (child && typeof child === 'object' && 'type' in child) {
-                            visit(child);
-                        }
-                    });
-                }
-                else if ('type' in value) {
-                    visit(value);
-                }
+  const usedImports = new Set();
+  function visit(n) {
+    if (n.type === 'Identifier' && importedNames.has(n.name)) {
+      usedImports.add(n.name);
+    }
+    // Recursively visit child nodes
+    for (const key in n) {
+      const value = n[key];
+      if (value && typeof value === 'object') {
+        if (Array.isArray(value)) {
+          value.forEach((child) => {
+            if (child && typeof child === 'object' && 'type' in child) {
+              visit(child);
             }
+          });
+        } else if ('type' in value) {
+          visit(value);
         }
+      }
     }
-    visit(node);
-    return Array.from(usedImports);
+  }
+  visit(node);
+  return Array.from(usedImports);
 }
 /**
  * Calculate import-based similarity between two exports (Jaccard index)
  */
 export function calculateImportSimilarity(export1, export2) {
-    if (export1.imports.length === 0 && export2.imports.length === 0) {
-        return 1; // Both have no imports = perfectly similar
-    }
-    const set1 = new Set(export1.imports);
-    const set2 = new Set(export2.imports);
-    const intersection = new Set([...set1].filter(x => set2.has(x)));
-    const union = new Set([...set1, ...set2]);
-    return intersection.size / union.size;
+  if (export1.imports.length === 0 && export2.imports.length === 0) {
+    return 1; // Both have no imports = perfectly similar
+  }
+  const set1 = new Set(export1.imports);
+  const set2 = new Set(export2.imports);
+  const intersection = new Set([...set1].filter((x) => set2.has(x)));
+  const union = new Set([...set1, ...set2]);
+  return intersection.size / union.size;
 }
 /**
  * Extract TypeScript type references from a node
  * Collects all type identifiers used in type annotations
  */
 function extractTypeReferences(node) {
-    const types = new Set();
-    function visit(n) {
-        if (!n || typeof n !== 'object')
-            return;
-        // Type references
-        if (n.type === 'TSTypeReference' && n.typeName) {
-            if (n.typeName.type === 'Identifier') {
-                types.add(n.typeName.name);
-            }
-            else if (n.typeName.type === 'TSQualifiedName') {
-                // Handle qualified names like A.B.C
-                let current = n.typeName;
-                while (current.type === 'TSQualifiedName') {
-                    if (current.right?.type === 'Identifier') {
-                        types.add(current.right.name);
-                    }
-                    current = current.left;
-                }
-                if (current.type === 'Identifier') {
-                    types.add(current.name);
-                }
-            }
+  const types = new Set();
+  function visit(n) {
+    if (!n || typeof n !== 'object') return;
+    // Type references
+    if (n.type === 'TSTypeReference' && n.typeName) {
+      if (n.typeName.type === 'Identifier') {
+        types.add(n.typeName.name);
+      } else if (n.typeName.type === 'TSQualifiedName') {
+        // Handle qualified names like A.B.C
+        let current = n.typeName;
+        while (current.type === 'TSQualifiedName') {
+          if (current.right?.type === 'Identifier') {
+            types.add(current.right.name);
+          }
+          current = current.left;
         }
-        // Interface references
-        if (n.type === 'TSInterfaceHeritage' && n.expression) {
-            if (n.expression.type === 'Identifier') {
-                types.add(n.expression.name);
-            }
-        }
-        // Recursively visit children
-        for (const key of Object.keys(n)) {
-            const value = n[key];
-            if (Array.isArray(value)) {
-                value.forEach(visit);
-            }
-            else if (value && typeof value === 'object') {
-                visit(value);
-            }
+        if (current.type === 'Identifier') {
+          types.add(current.name);
         }
+      }
+    }
+    // Interface references
+    if (n.type === 'TSInterfaceHeritage' && n.expression) {
+      if (n.expression.type === 'Identifier') {
+        types.add(n.expression.name);
+      }
+    }
+    // Recursively visit children
+    for (const key of Object.keys(n)) {
+      const value = n[key];
+      if (Array.isArray(value)) {
+        value.forEach(visit);
+      } else if (value && typeof value === 'object') {
+        visit(value);
+      }
     }
-    visit(node);
-    return Array.from(types);
+  }
+  visit(node);
+  return Array.from(types);
 }
 export function parseCode(code, language) {
-    // Deprecated: Use parseFileExports instead
-    return null;
+  // Deprecated: Use parseFileExports instead
+  return null;
 }
 export function extractFunctions(ast) {
-    // Deprecated
-    return [];
+  // Deprecated
+  return [];
 }
 export function extractImports(ast) {
-    // Deprecated
-    return [];
+  // Deprecated
+  return [];
 }
-//# sourceMappingURL=ast-parser.js.map
+//# sourceMappingURL=ast-parser.js.map

package/dist/utils/cli-helpers.d.ts

@@ -2,10 +2,10 @@
  * Common CLI configuration interface
  */
 export interface CLIOptions {
-    rootDir: string;
-    include?: string[];
-    exclude?: string[];
-    [key: string]: any;
+  rootDir: string;
+  include?: string[];
+  exclude?: string[];
+  [key: string]: any;
 }
 /**
  * Resolve output file path, defaulting to .aiready directory
@@ -15,23 +15,40 @@ export interface CLIOptions {
  * @param workingDir - Working directory (default: process.cwd())
  * @returns Resolved absolute path
  */
-export declare function resolveOutputPath(userPath: string | undefined, defaultFilename: string, workingDir?: string): string;
+export declare function resolveOutputPath(
+  userPath: string | undefined,
+  defaultFilename: string,
+  workingDir?: string
+): string;
 /**
  * Load and merge configuration with CLI options
  */
-export declare function loadMergedConfig<T extends Record<string, any>>(directory: string, defaults: T, cliOptions: Partial<T>): Promise<T & {
+export declare function loadMergedConfig<T extends Record<string, any>>(
+  directory: string,
+  defaults: T,
+  cliOptions: Partial<T>
+): Promise<
+  T & {
     rootDir: string;
-}>;
+  }
+>;
 /**
  * Handle JSON output for CLI commands
  */
-export declare function handleJSONOutput(data: any, outputFile?: string, successMessage?: string): void;
+export declare function handleJSONOutput(
+  data: any,
+  outputFile?: string,
+  successMessage?: string
+): void;
 /**
  * Common error handler for CLI commands
  */
-export declare function handleCLIError(error: unknown, commandName: string): never;
+export declare function handleCLIError(
+  error: unknown,
+  commandName: string
+): never;
 /**
  * Calculate elapsed time and format for display
  */
 export declare function getElapsedTime(startTime: number): string;
-//# sourceMappingURL=cli-helpers.d.ts.map
+//# sourceMappingURL=cli-helpers.d.ts.map

package/dist/utils/cli-helpers.js

@@ -9,68 +9,70 @@ import { loadConfig, mergeConfigWithDefaults } from '../index';
  * @param workingDir - Working directory (default: process.cwd())
  * @returns Resolved absolute path
  */
-export function resolveOutputPath(userPath, defaultFilename, workingDir = process.cwd()) {
-    let outputPath;
-    if (userPath) {
-        // User provided a path, use it as-is
-        outputPath = userPath;
-    }
-    else {
-        // Default to .aiready directory
-        const aireadyDir = join(workingDir, '.aiready');
-        outputPath = join(aireadyDir, defaultFilename);
-    }
-    // Ensure parent directory exists (works for both default and custom paths)
-    const parentDir = dirname(outputPath);
-    if (!existsSync(parentDir)) {
-        mkdirSync(parentDir, { recursive: true });
-    }
-    return outputPath;
+export function resolveOutputPath(
+  userPath,
+  defaultFilename,
+  workingDir = process.cwd()
+) {
+  let outputPath;
+  if (userPath) {
+    // User provided a path, use it as-is
+    outputPath = userPath;
+  } else {
+    // Default to .aiready directory
+    const aireadyDir = join(workingDir, '.aiready');
+    outputPath = join(aireadyDir, defaultFilename);
+  }
+  // Ensure parent directory exists (works for both default and custom paths)
+  const parentDir = dirname(outputPath);
+  if (!existsSync(parentDir)) {
+    mkdirSync(parentDir, { recursive: true });
+  }
+  return outputPath;
 }
 /**
  * Load and merge configuration with CLI options
  */
 export async function loadMergedConfig(directory, defaults, cliOptions) {
-    // Load config file if it exists
-    const config = await loadConfig(directory);
-    // Merge config with defaults
-    const mergedConfig = mergeConfigWithDefaults(config, defaults);
-    // Override with CLI options (CLI takes precedence)
-    const result = {
-        ...mergedConfig,
-        ...cliOptions,
-        rootDir: directory,
-    };
-    return result;
+  // Load config file if it exists
+  const config = await loadConfig(directory);
+  // Merge config with defaults
+  const mergedConfig = mergeConfigWithDefaults(config, defaults);
+  // Override with CLI options (CLI takes precedence)
+  const result = {
+    ...mergedConfig,
+    ...cliOptions,
+    rootDir: directory,
+  };
+  return result;
 }
 /**
  * Handle JSON output for CLI commands
  */
 export function handleJSONOutput(data, outputFile, successMessage) {
-    if (outputFile) {
-        // Ensure directory exists
-        const dir = dirname(outputFile);
-        if (!existsSync(dir)) {
-            mkdirSync(dir, { recursive: true });
-        }
-        writeFileSync(outputFile, JSON.stringify(data, null, 2));
-        console.log(successMessage || `✅ Results saved to ${outputFile}`);
-    }
-    else {
-        console.log(JSON.stringify(data, null, 2));
+  if (outputFile) {
+    // Ensure directory exists
+    const dir = dirname(outputFile);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
     }
+    writeFileSync(outputFile, JSON.stringify(data, null, 2));
+    console.log(successMessage || `✅ Results saved to ${outputFile}`);
+  } else {
+    console.log(JSON.stringify(data, null, 2));
+  }
 }
 /**
  * Common error handler for CLI commands
  */
 export function handleCLIError(error, commandName) {
-    console.error(`❌ ${commandName} failed:`, error);
-    process.exit(1);
+  console.error(`❌ ${commandName} failed:`, error);
+  process.exit(1);
 }
 /**
  * Calculate elapsed time and format for display
  */
 export function getElapsedTime(startTime) {
-    return ((Date.now() - startTime) / 1000).toFixed(2);
+  return ((Date.now() - startTime) / 1000).toFixed(2);
 }
-//# sourceMappingURL=cli-helpers.js.map
+//# sourceMappingURL=cli-helpers.js.map

package/dist/utils/config.d.ts

@@ -1,4 +1,9 @@
 import type { AIReadyConfig } from '../types';
-export declare function loadConfig(rootDir: string): Promise<AIReadyConfig | null>;
-export declare function mergeConfigWithDefaults(userConfig: AIReadyConfig | null, defaults: any): any;
-//# sourceMappingURL=config.d.ts.map
+export declare function loadConfig(
+  rootDir: string
+): Promise<AIReadyConfig | null>;
+export declare function mergeConfigWithDefaults(
+  userConfig: AIReadyConfig | null,
+  defaults: any
+): any;
+//# sourceMappingURL=config.d.ts.map