@soederpop/luca 0.1.2 → 0.2.1

package/dist/node/features/os.d.ts

@@ -0,0 +1,168 @@
+import { Feature } from '../feature.js';
+import os from 'os';
+/** Information about a connected display. */
+export interface DisplayInfo {
+    name: string;
+    resolution: {
+        width: number;
+        height: number;
+    };
+    retina: boolean;
+    main: boolean;
+    refreshRate?: number;
+    connectionType?: string;
+}
+/**
+ * The OS feature provides access to operating system utilities and information.
+ *
+ * This feature wraps Node.js's built-in `os` module and provides convenient
+ * getters for system information like architecture, platform, directories,
+ * network interfaces, and hardware details.
+ *
+ * @example
+ * ```typescript
+ * const osInfo = container.feature('os')
+ *
+ * console.log(`Platform: ${osInfo.platform}`)
+ * console.log(`Architecture: ${osInfo.arch}`)
+ * console.log(`CPU cores: ${osInfo.cpuCount}`)
+ * console.log(`Home directory: ${osInfo.homedir}`)
+ * ```
+ *
+ * @extends Feature
+ */
+export declare class OS extends Feature {
+    static shortcut: "features.os";
+    static stateSchema: import("zod").ZodObject<{
+        enabled: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    }, import("zod/v4/core").$loose>;
+    static optionsSchema: import("zod").ZodObject<{
+        name: import("zod").ZodOptional<import("zod").ZodString>;
+        _cacheKey: import("zod").ZodOptional<import("zod").ZodString>;
+        cached: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        enable: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, import("zod/v4/core").$strip>;
+    /**
+     * Gets the operating system CPU architecture.
+     *
+     * @returns {string} The CPU architecture (e.g., 'x64', 'arm64', 'arm', 'ia32')
+     *
+     * @example
+     * ```typescript
+     * const arch = os.arch
+     * console.log(`Running on ${arch} architecture`)
+     * ```
+     */
+    get arch(): string;
+    /**
+     * Gets the operating system's default directory for temporary files.
+     *
+     * @returns {string} The path to the temporary directory
+     *
+     * @example
+     * ```typescript
+     * const tempDir = os.tmpdir
+     * console.log(`Temp directory: ${tempDir}`)
+     * ```
+     */
+    get tmpdir(): string;
+    /**
+     * Gets the current user's home directory path.
+     *
+     * @returns {string} The path to the user's home directory
+     *
+     * @example
+     * ```typescript
+     * const home = os.homedir
+     * console.log(`User home: ${home}`)
+     * ```
+     */
+    get homedir(): string;
+    /**
+     * Gets the number of logical CPU cores available on the system.
+     *
+     * @returns {number} The number of CPU cores
+     *
+     * @example
+     * ```typescript
+     * const cores = os.cpuCount
+     * console.log(`System has ${cores} CPU cores`)
+     * ```
+     */
+    get cpuCount(): number;
+    /**
+     * Gets the hostname of the operating system.
+     *
+     * @returns {string} The system hostname
+     *
+     * @example
+     * ```typescript
+     * const hostname = os.hostname
+     * console.log(`Hostname: ${hostname}`)
+     * ```
+     */
+    get hostname(): string;
+    /**
+     * Gets the operating system platform.
+     *
+     * @returns {string} The platform identifier (e.g., 'darwin', 'linux', 'win32')
+     *
+     * @example
+     * ```typescript
+     * const platform = os.platform
+     * if (platform === 'darwin') {
+     *   console.log('Running on macOS')
+     * }
+     * ```
+     */
+    get platform(): string;
+    /**
+     * Gets information about the system's network interfaces.
+     *
+     * @returns {NodeJS.Dict<os.NetworkInterfaceInfo[]>} Object containing network interface details
+     *
+     * @example
+     * ```typescript
+     * const interfaces = os.networkInterfaces
+     * Object.keys(interfaces).forEach(name => {
+     *   console.log(`Interface ${name}:`, interfaces[name])
+     * })
+     * ```
+     */
+    get networkInterfaces(): NodeJS.Dict<os.NetworkInterfaceInfo[]>;
+    /**
+     * Gets an array of MAC addresses for non-internal IPv4 network interfaces.
+     *
+     * This filters the network interfaces to only include external IPv4 interfaces
+     * and returns their MAC addresses, which can be useful for system identification.
+     *
+     * @returns {string[]} Array of MAC addresses for external IPv4 interfaces
+     *
+     * @example
+     * ```typescript
+     * const macAddresses = os.macAddresses
+     * console.log(`External MAC addresses: ${macAddresses.join(', ')}`)
+     * ```
+     */
+    get macAddresses(): string[];
+    /**
+     * Gets information about all connected displays.
+     *
+     * Platform-specific: currently implemented for macOS (darwin).
+     * Linux and Windows will throw with a clear "not yet implemented" message.
+     *
+     * @returns {DisplayInfo[]} Array of display information objects
+     *
+     * @example
+     * ```typescript
+     * const displays = os.getDisplayInfo()
+     * displays.forEach(d => {
+     *   console.log(`${d.name}: ${d.resolution.width}x${d.resolution.height}${d.retina ? ' (Retina)' : ''}`)
+     * })
+     * ```
+     */
+    getDisplayInfo(): DisplayInfo[];
+    private _displayHandlers;
+}
+export default OS;
+//# sourceMappingURL=os.d.ts.map

package/dist/node/features/os.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"os.d.ts","sourceRoot":"","sources":["../../../src/node/features/os.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAEvC,OAAO,EAAE,MAAM,IAAI,CAAA;AAEnB,6CAA6C;AAC7C,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAA;IAC7C,MAAM,EAAE,OAAO,CAAA;IACf,IAAI,EAAE,OAAO,CAAA;IACb,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,EAAG,SAAQ,OAAO;IAC7B,OAAgB,QAAQ,EAAG,aAAa,CAAS;IACjD,OAAgB,WAAW;;qCAAqB;IAChD,OAAgB,aAAa;;;;;qCAAuB;IAGpD;;;;;;;;;;OAUG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;;;;;;;;OAUG;IACH,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED;;;;;;;;;;OAUG;IACH,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED;;;;;;;;;;OAUG;IACH,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED;;;;;;;;;;OAUG;IACH,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED;;;;;;;;;;;;OAYG;IACH,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED;;;;;;;;;;;;OAYG;IACH,IAAI,iBAAiB,IAAI,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,oBAAoB,EAAE,CAAC,CAE9D;IAED;;;;;;;;;;;;;OAaG;IACH,IAAI,YAAY,IAAK,MAAM,EAAE,CAE5B;IAED;;;;;;;;;;;;;;;OAeG;IACH,cAAc,IAAI,WAAW,EAAE;IAW/B,OAAO,CAAC,gBAAgB,CAqCvB;CACF;AAED,eAAe,EAAE,CAAA"}

package/dist/node/features/package-finder.d.ts

@@ -0,0 +1,419 @@
+import { z } from 'zod';
+import { Feature } from "../feature.js";
+/**
+ * Index mapping package names to arrays of package manifests with their file paths.
+ * Used for efficient lookup and duplicate detection.
+ *
+ * @type PackageIndex
+ */
+type PackageIndex = {
+    [name: string]: Array<PartialManifest & {
+        /** The file system path to the package.json file */
+        __path: string;
+    }>;
+};
+/**
+ * Zod schema for the PackageFinder feature state.
+ * Tracks the initialization status of the package scanning process.
+ */
+export declare const PackageFinderStateSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    started: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+export type PackageFinderState = z.infer<typeof PackageFinderStateSchema>;
+/**
+ * Zod schema for the PackageFinder feature options.
+ */
+export declare const PackageFinderOptionsSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    _cacheKey: z.ZodOptional<z.ZodString>;
+    cached: z.ZodOptional<z.ZodBoolean>;
+    enable: z.ZodOptional<z.ZodBoolean>;
+    option: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PackageFinderOptions = z.infer<typeof PackageFinderOptionsSchema>;
+/**
+ * Partial representation of a package.json manifest file.
+ * Contains the most commonly used fields for package analysis and dependency management.
+ *
+ * @type PartialManifest
+ */
+export type PartialManifest = {
+    /** The package name (e.g., 'lodash', '@types/node') */
+    name: string;
+    /** The package version (e.g., '1.0.0', '^2.1.3') */
+    version: string;
+    /** Optional package description */
+    description?: string;
+    /** Runtime dependencies with version constraints */
+    dependencies?: Record<string, Record<string, string>>;
+    /** Development dependencies with version constraints */
+    devDependencies?: Record<string, Record<string, string>>;
+    /** Peer dependencies with version constraints */
+    peerDependencies?: Record<string, Record<string, string>>;
+    /** Optional dependencies with version constraints */
+    optionalDependencies?: Record<string, Record<string, string>>;
+};
+/**
+ * PackageFinder Feature - Comprehensive package discovery and analysis tool
+ *
+ * This feature provides powerful capabilities for discovering, indexing, and analyzing
+ * npm packages across the entire project workspace. It recursively scans all node_modules
+ * directories and builds a comprehensive index of packages, enabling:
+ *
+ * **Core Functionality:**
+ * - Recursive node_modules scanning across the workspace
+ * - Package manifest parsing and indexing
+ * - Duplicate package detection and analysis
+ * - Dependency relationship mapping
+ * - Scoped package organization (@scope/package)
+ * - Package count and statistics
+ *
+ * **Use Cases:**
+ * - Dependency auditing and analysis
+ * - Duplicate package identification
+ * - Package version conflict detection
+ * - Dependency tree analysis
+ * - Workspace package inventory
+ *
+ * **Performance Features:**
+ * - Parallel manifest reading for fast scanning
+ * - Efficient duplicate detection using unique paths
+ * - Lazy initialization - only scans when started
+ * - In-memory indexing for fast queries
+ *
+ * **Usage Example:**
+ * ```typescript
+ * const finder = container.feature('packageFinder');
+ * await finder.start();
+ *
+ * // Find duplicates
+ * console.log('Duplicate packages:', finder.duplicates);
+ *
+ * // Find package by name
+ * const lodash = finder.findByName('lodash');
+ *
+ * // Find dependents of a package
+ * const dependents = finder.findDependentsOf('react');
+ * ```
+ *
+ * @template T - The state type, defaults to PackageFinderState
+ * @template K - The options type, defaults to PackageFinderOptions
+ * @extends {Feature<T, K>}
+ */
+export declare class PackageFinder<T extends PackageFinderState = PackageFinderState, K extends PackageFinderOptions = PackageFinderOptions> extends Feature<T, K> {
+    /** The shortcut path for accessing this feature */
+    static shortcut: "features.packageFinder";
+    static stateSchema: z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        started: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>;
+    static optionsSchema: z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        _cacheKey: z.ZodOptional<z.ZodString>;
+        cached: z.ZodOptional<z.ZodBoolean>;
+        enable: z.ZodOptional<z.ZodBoolean>;
+        option: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    /** Internal package index mapping names to manifest arrays */
+    packages: PackageIndex;
+    /**
+     * Initializes the feature state after construction.
+     * Sets the started flag to false, indicating the initial scan hasn't completed.
+     */
+    afterInitialize(): void;
+    /**
+     * Adds a package manifest to the internal index.
+     *
+     * This method ensures uniqueness based on file path and maintains an array
+     * of all versions/instances of each package found across the workspace.
+     * Packages with the same name but different paths (versions) are tracked separately.
+     *
+     * @param manifest - The package manifest data from package.json
+     * @param path - The file system path to the package.json file
+     *
+     * @example
+     * ```typescript
+     * finder.addPackage({
+     *   name: 'lodash',
+     *   version: '4.17.21',
+     *   description: 'A modern JavaScript utility library'
+     * }, '/project/node_modules/lodash/package.json');
+     * ```
+     */
+    addPackage(manifest: PartialManifest, path: string): void;
+    /**
+     * Gets a list of package names that have multiple versions/instances installed.
+     *
+     * This is useful for identifying potential dependency conflicts or
+     * opportunities for deduplication in the project.
+     *
+     * @returns Array of package names that appear multiple times in the workspace
+     *
+     * @example
+     * ```typescript
+     * const duplicates = finder.duplicates;
+     * // ['lodash', 'react', '@types/node'] - packages with multiple versions
+     *
+     * duplicates.forEach(name => {
+     *   console.log(`${name} has ${finder.packages[name].length} versions`);
+     * });
+     * ```
+     */
+    get duplicates(): string[];
+    /**
+     * Starts the package finder and performs the initial workspace scan.
+     *
+     * This method is idempotent - calling it multiple times will not re-scan
+     * if already started. It triggers the complete workspace scanning process.
+     *
+     * @returns Promise resolving to this instance for method chaining
+     *
+     * @example
+     * ```typescript
+     * await finder.start();
+     * console.log(`Found ${finder.packageNames.length} unique packages`);
+     * ```
+     */
+    start(): Promise<this | undefined>;
+    /**
+     * Performs a comprehensive scan of all node_modules directories in the workspace.
+     *
+     * This method orchestrates the complete scanning process:
+     * 1. Discovers all node_modules directories recursively
+     * 2. Finds all package directories (including scoped packages)
+     * 3. Reads and parses all package.json files in parallel
+     * 4. Indexes all packages for fast querying
+     *
+     * The scan is performed in parallel for optimal performance, reading multiple
+     * package.json files simultaneously.
+     *
+     * @param options - Scanning options (currently unused)
+     * @param options.exclude - Optional exclusion patterns (not implemented)
+     * @returns Promise resolving to this instance for method chaining
+     *
+     * @example
+     * ```typescript
+     * // Manual scan (usually called automatically by start())
+     * await finder.scan();
+     *
+     * // Check results
+     * console.log(`Scanned ${finder.manifests.length} packages`);
+     * ```
+     */
+    scan(options?: {
+        exclude?: string | string[];
+    }): Promise<this>;
+    /**
+     * Checks if the package finder has completed its initial scan.
+     *
+     * @returns True if the finder has been started and scanning is complete
+     */
+    get isStarted(): boolean;
+    /**
+     * Gets an array of all unique package names discovered in the workspace.
+     *
+     * @returns Array of package names (e.g., ['lodash', 'react', '@types/node'])
+     *
+     * @example
+     * ```typescript
+     * const names = finder.packageNames;
+     * console.log(`Found ${names.length} unique packages`);
+     * ```
+     */
+    get packageNames(): string[];
+    /**
+     * Gets an array of all scoped package prefixes found in the workspace.
+     *
+     * Scoped packages are those starting with '@' (e.g., @types/node, @babel/core).
+     * This returns just the scope part (e.g., '@types', '@babel').
+     *
+     * @returns Array of unique scope names without duplicates
+     *
+     * @example
+     * ```typescript
+     * const scopes = finder.scopes;
+     * // ['@types', '@babel', '@angular'] - all scopes in use
+     *
+     * scopes.forEach(scope => {
+     *   const scopedPackages = finder.packageNames.filter(name => name.startsWith(scope));
+     *   console.log(`${scope}: ${scopedPackages.length} packages`);
+     * });
+     * ```
+     */
+    get scopes(): string[];
+    /**
+     * Finds the first package manifest matching the given name.
+     *
+     * If multiple versions of the package exist, returns the first one found.
+     * Use the packages property directly if you need all versions.
+     *
+     * @param name - The exact package name to search for
+     * @returns The first matching package manifest, or undefined if not found
+     *
+     * @example
+     * ```typescript
+     * const lodash = finder.findByName('lodash');
+     * if (lodash) {
+     *   console.log(`Found lodash version ${lodash.version}`);
+     * }
+     * ```
+     */
+    findByName(name: string): PartialManifest | undefined;
+    /**
+     * Finds all packages that declare the specified package as a dependency.
+     *
+     * Searches through dependencies and devDependencies of all packages
+     * to find which ones depend on the target package. Useful for impact
+     * analysis when considering package updates or removals.
+     *
+     * @param packageName - The name of the package to find dependents for
+     * @returns Array of package manifests that depend on the specified package
+     *
+     * @example
+     * ```typescript
+     * const reactDependents = finder.findDependentsOf('react');
+     * console.log(`${reactDependents.length} packages depend on React:`);
+     * reactDependents.forEach(pkg => {
+     *   console.log(`- ${pkg.name}@${pkg.version}`);
+     * });
+     * ```
+     */
+    findDependentsOf(packageName: string): PartialManifest[];
+    /**
+     * Finds the first package manifest matching the provided filter function.
+     *
+     * @param filter - Function that returns true for matching packages
+     * @returns The first matching package manifest, or undefined if none found
+     *
+     * @example
+     * ```typescript
+     * // Find a package with specific version
+     * const specific = finder.find(pkg => pkg.name === 'lodash' && pkg.version.startsWith('4.'));
+     *
+     * // Find a package with description containing keyword
+     * const utility = finder.find(pkg => pkg.description?.includes('utility'));
+     * ```
+     */
+    find(filter: (manifest: PartialManifest) => boolean): PartialManifest | undefined;
+    /**
+     * Finds all package manifests matching the provided filter function.
+     *
+     * @param filter - Function that returns true for matching packages
+     * @returns Array of matching package manifests
+     *
+     * @example
+     * ```typescript
+     * // Find all packages with 'babel' in the name
+     * const babelPackages = finder.filter(pkg => pkg.name.includes('babel'));
+     *
+     * // Find all packages with no description
+     * const undocumented = finder.filter(pkg => !pkg.description);
+     *
+     * // Find all scoped packages
+     * const scoped = finder.filter(pkg => pkg.name.startsWith('@'));
+     * ```
+     */
+    filter(filter: (manifest: PartialManifest) => boolean): PartialManifest[];
+    /**
+     * Returns all packages that do NOT match the provided filter function.
+     *
+     * This is the inverse of filter() - returns packages where filter returns false.
+     *
+     * @param filter - Function that returns true for packages to exclude
+     * @returns Array of package manifests that don't match the filter
+     *
+     * @example
+     * ```typescript
+     * // Get all non-development packages (those not in devDependencies)
+     * const prodPackages = finder.exclude(pkg => isDevDependency(pkg.name));
+     *
+     * // Get all non-scoped packages
+     * const unscoped = finder.exclude(pkg => pkg.name.startsWith('@'));
+     * ```
+     */
+    exclude(filter: (manifest: PartialManifest) => boolean): PartialManifest[];
+    /**
+     * Gets a flat array of all package manifests found in the workspace.
+     *
+     * This includes all versions/instances of packages, unlike packageNames
+     * which returns unique names only.
+     *
+     * @returns Array of all package manifests with their metadata
+     *
+     * @example
+     * ```typescript
+     * const all = finder.manifests;
+     * console.log(`Total package instances: ${all.length}`);
+     *
+     * // Group by name to see duplicates
+     * const grouped = all.reduce((acc, pkg) => {
+     *   acc[pkg.name] = (acc[pkg.name] || 0) + 1;
+     *   return acc;
+     * }, {});
+     * ```
+     */
+    get manifests(): (PartialManifest & {
+        __path: string;
+    })[];
+    /**
+     * Gets a count of instances for each package name.
+     *
+     * Useful for quickly identifying which packages have multiple versions
+     * and how many instances of each exist.
+     *
+     * @returns Object mapping package names to their instance counts
+     *
+     * @example
+     * ```typescript
+     * const counts = finder.counts;
+     * // { 'lodash': 3, 'react': 2, 'express': 1 }
+     *
+     * Object.entries(counts)
+     *   .filter(([name, count]) => count > 1)
+     *   .forEach(([name, count]) => {
+     *     console.log(`${name}: ${count} versions installed`);
+     *   });
+     * ```
+     */
+    get counts(): Record<string, number>;
+    /**
+     * Discovers all package directories within a specific node_modules directory.
+     *
+     * Handles both regular packages and scoped packages (@scope/package).
+     * Scoped packages require additional directory traversal as they are nested
+     * under scope directories.
+     *
+     * @param nodeModulesPath - Path to a node_modules directory to scan
+     * @returns Promise resolving to array of package directory paths
+     *
+     * @private
+     */
+    private findPackageFolders;
+    findLocalPackageFolders(): Promise<string[]>;
+    /**
+     * Discovers all package directories across all node_modules in the workspace.
+     *
+     * Combines results from all discovered node_modules directories to provide
+     * a comprehensive list of all package installations.
+     *
+     * @returns Promise resolving to array of all package directory paths
+     *
+     * @private
+     */
+    private findAllPackageFolders;
+    /**
+     * Discovers all node_modules directories in the workspace hierarchy.
+     *
+     * Uses the container's file system utilities to recursively search upward
+     * from the current working directory to find all node_modules directories.
+     * This supports monorepos and nested project structures.
+     *
+     * @returns Promise resolving to array of node_modules directory paths
+     *
+     * @private
+     */
+    private findNodeModulesFolders;
+}
+export default PackageFinder;
+//# sourceMappingURL=package-finder.d.ts.map

package/dist/node/features/package-finder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-finder.d.ts","sourceRoot":"","sources":["../../../src/node/features/package-finder.ts"],"names":[],"mappings":"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"}