@ginkoai/cli 1.0.0 → 1.4.1

package/dist/core/config/config-aware-reflection.js

@@ -1,97 +0,0 @@
-/**
- * @fileType: utility
- * @status: current
- * @updated: 2025-09-21
- * @tags: [reflection, config-aware, paths, documents, base-class]
- * @related: [reflection-pattern.ts, config-loader.ts, reflectors]
- * @priority: high
- * @complexity: medium
- * @dependencies: [reflection-pattern, config-loader, fs-extra, path, path-config]
- */
-import { ReflectionCommand } from '../reflection-pattern.js';
-import { configLoader } from './config-loader.js';
-import { pathManager } from './path-config.js';
-import fs from 'fs-extra';
-import path from 'path';
-import chalk from 'chalk';
-/**
- * Configuration-aware reflection base class
- * Handles path resolution and document naming using pathManager
- */
-export class ConfigAwareReflectionCommand extends ReflectionCommand {
-    config = null;
-    constructor(domain) {
-        super(domain);
-    }
-    /**
-     * Load configuration before executing
-     */
-    async execute(intent, options = {}) {
-        // Load configuration
-        this.config = await configLoader.loadConfig();
-        // Call parent execute
-        await super.execute(intent, options);
-    }
-    /**
-     * Save artifact using configuration-based paths
-     */
-    async saveArtifact(content, filename) {
-        if (!this.config) {
-            throw new Error('Configuration not loaded');
-        }
-        // Get the configured path for this domain
-        const documentPath = await this.getDocumentPath();
-        await fs.ensureDir(documentPath);
-        // Generate filename if not provided
-        if (!filename) {
-            filename = await this.generateDocumentName(content);
-        }
-        const filePath = path.join(documentPath, filename);
-        await fs.writeFile(filePath, content, 'utf8');
-        console.log(chalk.green(`✓ Saved to: ${filePath}`));
-        return filePath;
-    }
-    /**
-     * Get document path for this domain using pathManager
-     */
-    async getDocumentPath() {
-        try {
-            // Map domain to configuration path using pathManager
-            const pathConfig = pathManager.getConfig();
-            const pathMapping = {
-                'prd': pathConfig.docs.prd,
-                'architecture': pathConfig.docs.adr,
-                'adr': pathConfig.docs.adr,
-                'sprint': pathConfig.docs.sprints,
-                'backlog': pathConfig.ginko.backlog,
-                'documentation': pathConfig.docs.root
-            };
-            const documentPath = pathMapping[this.domain];
-            if (!documentPath) {
-                throw new Error(`No path configured for domain: ${this.domain}`);
-            }
-            return documentPath;
-        }
-        catch (error) {
-            // Fallback to default paths if configuration fails
-            console.warn(chalk.yellow(`Warning: Using fallback path for ${this.domain}`));
-            return this.getFallbackPath();
-        }
-    }
-    /**
-     * Get fallback path when configuration fails - now using pathManager
-     */
-    getFallbackPath() {
-        const pathConfig = pathManager.getConfig();
-        const fallbackPaths = {
-            'prd': pathConfig.docs.prd,
-            'architecture': pathConfig.docs.adr,
-            'adr': pathConfig.docs.adr,
-            'sprint': pathConfig.docs.sprints,
-            'backlog': pathConfig.ginko.backlog,
-            'documentation': pathConfig.docs.root
-        };
-        return fallbackPaths[this.domain] || pathConfig.docs.root;
-    }
-}
-//# sourceMappingURL=config-aware-reflection.js.map

package/dist/core/config/config-aware-reflection.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"config-aware-reflection.js","sourceRoot":"","sources":["../../../src/core/config/config-aware-reflection.ts"],"names":[],"mappings":"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"}

package/dist/core/config/config-loader.d.ts

@@ -1,154 +0,0 @@
-/**
- * @fileType: utility
- * @status: current
- * @updated: 2025-09-19
- * @tags: [config, loader, singleton, defaults, caching]
- * @related: [config-schema.ts, path-resolver.ts, config-migrator.ts]
- * @priority: critical
- * @complexity: high
- * @dependencies: [fs, path]
- */
-import { GinkoConfig } from './config-schema.js';
-import { PathResolver } from './path-resolver.js';
-/**
- * Configuration Loader with Singleton Pattern
- * Implements ADR-028 First-Use Experience Enhancement Architecture
- */
-export interface LoaderOptions {
-    /** Project root directory (defaults to cwd) */
-    projectRoot?: string;
-    /** Configuration file name (defaults to 'ginko.json') */
-    configFileName?: string;
-    /** Force reload from disk, ignoring cache */
-    forceReload?: boolean;
-    /** Enable automatic migration */
-    autoMigrate?: boolean;
-    /** Validation strictness level */
-    validation?: 'strict' | 'loose' | 'none';
-}
-export interface LoadResult {
-    /** Loaded configuration */
-    config: GinkoConfig;
-    /** Path to configuration file */
-    configPath: string;
-    /** Whether config was loaded from file or defaults */
-    fromFile: boolean;
-    /** Whether config was migrated */
-    migrated: boolean;
-    /** Path resolver instance */
-    resolver: PathResolver;
-    /** Validation warnings */
-    warnings: string[];
-    /** Load timestamp */
-    loadedAt: Date;
-}
-export declare class ConfigLoadError extends Error {
-    configPath?: string | undefined;
-    cause?: Error | undefined;
-    constructor(message: string, configPath?: string | undefined, cause?: Error | undefined);
-}
-/**
- * ConfigLoader singleton for managing ginko configuration
- */
-export declare class ConfigLoader {
-    private static instance;
-    private cachedResult;
-    private loadPromise;
-    private constructor();
-    /**
-     * Get the singleton instance
-     */
-    static getInstance(): ConfigLoader;
-    /**
-     * Reset the singleton (useful for testing)
-     */
-    static reset(): void;
-    /**
-     * Load configuration with caching and graceful fallback
-     */
-    load(options?: LoaderOptions): Promise<LoadResult>;
-    /**
-     * Internal loading logic
-     */
-    private doLoad;
-    /**
-     * Save configuration to file
-     */
-    save(config: GinkoConfig, options?: LoaderOptions): Promise<void>;
-    /**
-     * Create default configuration with platform detection
-     */
-    private createDefaultConfig;
-    /**
-     * Detect current platform configuration
-     */
-    private detectPlatform;
-    /**
-     * Get platform-specific configurations
-     */
-    private getPlatformSpecific;
-    /**
-     * Detect Linux distribution
-     */
-    private detectLinuxDistribution;
-    /**
-     * Check if configuration needs migration
-     */
-    private needsMigration;
-    /**
-     * Merge user configuration with defaults
-     */
-    private mergeWithDefaults;
-    /**
-     * Create path resolver from configuration
-     */
-    private createPathResolver;
-    /**
-     * Get current configuration without loading
-     */
-    getCached(): LoadResult | null;
-    /**
-     * Check if configuration exists
-     */
-    exists(options?: LoaderOptions): Promise<boolean>;
-    /**
-     * Initialize a new configuration file
-     */
-    initialize(options?: LoaderOptions): Promise<LoadResult>;
-    /**
-     * Invalidate cache
-     */
-    invalidateCache(): void;
-    /**
-     * Get configuration statistics
-     */
-    getStats(): {
-        cached: boolean;
-        loadedAt?: Date;
-        configPath?: string;
-        fromFile?: boolean;
-        migrated?: boolean;
-    };
-}
-/**
- * Convenience functions for common operations
- */
-export declare namespace ConfigLoaderUtils {
-    /**
-     * Quick load with defaults
-     */
-    function quickLoad(projectRoot?: string): Promise<GinkoConfig>;
-    /**
-     * Get resolved path from configuration
-     */
-    function getResolvedPath(pathKey: string, projectRoot?: string): Promise<string>;
-    /**
-     * Check if a feature is enabled
-     */
-    function isFeatureEnabled(feature: string, projectRoot?: string): Promise<boolean>;
-    /**
-     * Update a single configuration value
-     */
-    function updateConfig(updates: Partial<GinkoConfig>, projectRoot?: string): Promise<void>;
-}
-//# sourceMappingURL=config-loader.d.ts.map

package/dist/core/config/config-loader.d.ts.map

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

package/dist/core/config/config-loader.js

@@ -1,424 +0,0 @@
-/**
- * @fileType: utility
- * @status: current
- * @updated: 2025-09-19
- * @tags: [config, loader, singleton, defaults, caching]
- * @related: [config-schema.ts, path-resolver.ts, config-migrator.ts]
- * @priority: critical
- * @complexity: high
- * @dependencies: [fs, path]
- */
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import { DEFAULT_CONFIG, validateConfig, ConfigValidationError } from './config-schema.js';
-import { PathResolver } from './path-resolver.js';
-export class ConfigLoadError extends Error {
-    configPath;
-    cause;
-    constructor(message, configPath, cause) {
-        super(message);
-        this.configPath = configPath;
-        this.cause = cause;
-        this.name = 'ConfigLoadError';
-    }
-}
-/**
- * ConfigLoader singleton for managing ginko configuration
- */
-export class ConfigLoader {
-    static instance = null;
-    cachedResult = null;
-    loadPromise = null;
-    constructor() {
-        // Private constructor for singleton
-    }
-    /**
-     * Get the singleton instance
-     */
-    static getInstance() {
-        if (!ConfigLoader.instance) {
-            ConfigLoader.instance = new ConfigLoader();
-        }
-        return ConfigLoader.instance;
-    }
-    /**
-     * Reset the singleton (useful for testing)
-     */
-    static reset() {
-        ConfigLoader.instance = null;
-    }
-    /**
-     * Load configuration with caching and graceful fallback
-     */
-    async load(options = {}) {
-        const { projectRoot = process.cwd(), configFileName = 'ginko.json', forceReload = false, autoMigrate = true, validation = 'strict' } = options;
-        // Return cached result if available and not forcing reload
-        if (this.cachedResult && !forceReload) {
-            return this.cachedResult;
-        }
-        // If already loading, return the same promise
-        if (this.loadPromise && !forceReload) {
-            return this.loadPromise;
-        }
-        // Start loading
-        this.loadPromise = this.doLoad(projectRoot, configFileName, autoMigrate, validation);
-        try {
-            const result = await this.loadPromise;
-            this.cachedResult = result;
-            return result;
-        }
-        finally {
-            this.loadPromise = null;
-        }
-    }
-    /**
-     * Internal loading logic
-     */
-    async doLoad(projectRoot, configFileName, autoMigrate, validation) {
-        const configPath = path.join(projectRoot, configFileName);
-        const warnings = [];
-        try {
-            // Try to load from file
-            const fileContent = await fs.readFile(configPath, 'utf-8');
-            let config;
-            try {
-                config = JSON.parse(fileContent);
-            }
-            catch (parseError) {
-                throw new ConfigLoadError(`Invalid JSON in configuration file: ${configPath}`, configPath, parseError instanceof Error ? parseError : new Error('Parse error'));
-            }
-            // Validate configuration
-            if (validation !== 'none') {
-                const validationResult = validateConfig(config);
-                if (!validationResult.valid) {
-                    if (validation === 'strict') {
-                        throw new ConfigValidationError(`Configuration validation failed: ${validationResult.errors.join(', ')}`);
-                    }
-                    else {
-                        warnings.push(...validationResult.errors);
-                    }
-                }
-            }
-            // Handle migration if needed
-            let migrated = false;
-            if (autoMigrate && this.needsMigration(config)) {
-                const { ConfigMigrator } = await import('./config-migrator.js');
-                const migrator = new ConfigMigrator();
-                config = await migrator.migrate(config);
-                migrated = true;
-                warnings.push('Configuration was automatically migrated to current version');
-            }
-            // Merge with defaults for any missing fields
-            const mergedConfig = this.mergeWithDefaults(config);
-            // Create path resolver
-            const resolver = this.createPathResolver(mergedConfig);
-            return {
-                config: mergedConfig,
-                configPath,
-                fromFile: true,
-                migrated,
-                resolver,
-                warnings,
-                loadedAt: new Date()
-            };
-        }
-        catch (error) {
-            if (error instanceof ConfigLoadError || error instanceof ConfigValidationError) {
-                throw error;
-            }
-            // File doesn't exist or other IO error - use defaults
-            if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
-                warnings.push(`Configuration file not found at ${configPath}, using defaults`);
-            }
-            else {
-                warnings.push(`Failed to load configuration: ${error instanceof Error ? error.message : 'Unknown error'}`);
-            }
-            const defaultConfig = this.createDefaultConfig();
-            const resolver = this.createPathResolver(defaultConfig);
-            return {
-                config: defaultConfig,
-                configPath,
-                fromFile: false,
-                migrated: false,
-                resolver,
-                warnings,
-                loadedAt: new Date()
-            };
-        }
-    }
-    /**
-     * Save configuration to file
-     */
-    async save(config, options = {}) {
-        const { projectRoot = process.cwd(), configFileName = 'ginko.json' } = options;
-        const configPath = path.join(projectRoot, configFileName);
-        // Validate before saving
-        const validationResult = validateConfig(config);
-        if (!validationResult.valid) {
-            throw new ConfigValidationError(`Cannot save invalid configuration: ${validationResult.errors.join(', ')}`);
-        }
-        // Update metadata
-        const configWithMetadata = {
-            ...config,
-            metadata: {
-                ...config.metadata,
-                updatedAt: new Date().toISOString(),
-                updatedBy: process.env.USER || process.env.USERNAME || 'unknown'
-            }
-        };
-        try {
-            // Ensure directory exists
-            await fs.mkdir(path.dirname(configPath), { recursive: true });
-            // Write file with pretty formatting
-            await fs.writeFile(configPath, JSON.stringify(configWithMetadata, null, 2) + '\n', 'utf-8');
-            // Clear cache to force reload
-            this.cachedResult = null;
-        }
-        catch (error) {
-            throw new ConfigLoadError(`Failed to save configuration to ${configPath}`, configPath, error instanceof Error ? error : new Error('Unknown error'));
-        }
-    }
-    /**
-     * Create default configuration with platform detection
-     */
-    createDefaultConfig() {
-        const platform = this.detectPlatform();
-        return {
-            ...DEFAULT_CONFIG,
-            platform,
-            metadata: {
-                createdAt: new Date().toISOString(),
-                updatedAt: new Date().toISOString(),
-                updatedBy: process.env.USER || process.env.USERNAME || 'unknown',
-                migrationHistory: []
-            }
-        };
-    }
-    /**
-     * Detect current platform configuration
-     */
-    detectPlatform() {
-        const type = PathResolver.detectPlatform();
-        const homeDirectory = require('os').homedir();
-        // Detect shell
-        let shell = 'bash';
-        if (type === 'windows') {
-            shell = process.env.ComSpec?.includes('powershell') ? 'powershell' : 'cmd';
-        }
-        else {
-            shell = path.basename(process.env.SHELL || 'bash');
-        }
-        return {
-            type,
-            shell,
-            pathSeparator: path.sep,
-            homeDirectory,
-            specific: this.getPlatformSpecific(type)
-        };
-    }
-    /**
-     * Get platform-specific configurations
-     */
-    getPlatformSpecific(type) {
-        switch (type) {
-            case 'windows':
-                return {
-                    windows: {
-                        useWSL: !!process.env.WSL_DISTRO_NAME,
-                        wslDistro: process.env.WSL_DISTRO_NAME
-                    }
-                };
-            case 'macos':
-                return {
-                    macos: {
-                        brewPrefix: process.env.HOMEBREW_PREFIX || '/opt/homebrew'
-                    }
-                };
-            case 'linux':
-                return {
-                    linux: {
-                        distribution: this.detectLinuxDistribution()
-                    }
-                };
-        }
-    }
-    /**
-     * Detect Linux distribution
-     */
-    detectLinuxDistribution() {
-        try {
-            // This is a simplified detection - could be enhanced
-            if (process.env.DEBIAN_FRONTEND)
-                return 'debian';
-            if (process.env.RHEL_VERSION)
-                return 'rhel';
-            return 'unknown';
-        }
-        catch {
-            return 'unknown';
-        }
-    }
-    /**
-     * Check if configuration needs migration
-     */
-    needsMigration(config) {
-        if (!config.version)
-            return true;
-        if (config.version !== DEFAULT_CONFIG.version)
-            return true;
-        return false;
-    }
-    /**
-     * Merge user configuration with defaults
-     */
-    mergeWithDefaults(userConfig) {
-        const defaultConfig = this.createDefaultConfig();
-        return {
-            version: userConfig.version || defaultConfig.version,
-            paths: {
-                docs: { ...defaultConfig.paths.docs, ...userConfig.paths?.docs },
-                ginko: { ...defaultConfig.paths.ginko, ...userConfig.paths?.ginko }
-            },
-            features: { ...defaultConfig.features, ...userConfig.features },
-            platform: userConfig.platform || defaultConfig.platform,
-            metadata: { ...defaultConfig.metadata, ...userConfig.metadata }
-        };
-    }
-    /**
-     * Create path resolver from configuration
-     */
-    createPathResolver(config) {
-        // Flatten path configuration for resolver
-        const variables = {};
-        // Add docs paths
-        for (const [key, value] of Object.entries(config.paths.docs)) {
-            variables[`docs.${key}`] = value;
-        }
-        // Add ginko paths
-        for (const [key, value] of Object.entries(config.paths.ginko)) {
-            variables[`ginko.${key}`] = value;
-        }
-        return PathResolver.create(variables);
-    }
-    /**
-     * Get current configuration without loading
-     */
-    getCached() {
-        return this.cachedResult;
-    }
-    /**
-     * Check if configuration exists
-     */
-    async exists(options = {}) {
-        const { projectRoot = process.cwd(), configFileName = 'ginko.json' } = options;
-        const configPath = path.join(projectRoot, configFileName);
-        try {
-            await fs.access(configPath);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Initialize a new configuration file
-     */
-    async initialize(options = {}) {
-        const { projectRoot = process.cwd(), configFileName = 'ginko.json' } = options;
-        const configPath = path.join(projectRoot, configFileName);
-        // Check if file already exists
-        if (await this.exists(options)) {
-            throw new ConfigLoadError(`Configuration file already exists at ${configPath}`, configPath);
-        }
-        // Create default configuration
-        const config = this.createDefaultConfig();
-        // Save to file
-        await this.save(config, options);
-        // Return load result
-        return this.load({ ...options, forceReload: true });
-    }
-    /**
-     * Invalidate cache
-     */
-    invalidateCache() {
-        this.cachedResult = null;
-    }
-    /**
-     * Get configuration statistics
-     */
-    getStats() {
-        if (!this.cachedResult) {
-            return { cached: false };
-        }
-        return {
-            cached: true,
-            loadedAt: this.cachedResult.loadedAt,
-            configPath: this.cachedResult.configPath,
-            fromFile: this.cachedResult.fromFile,
-            migrated: this.cachedResult.migrated
-        };
-    }
-}
-/**
- * Convenience functions for common operations
- */
-export var ConfigLoaderUtils;
-(function (ConfigLoaderUtils) {
-    /**
-     * Quick load with defaults
-     */
-    async function quickLoad(projectRoot) {
-        const loader = ConfigLoader.getInstance();
-        const result = await loader.load({ projectRoot });
-        return result.config;
-    }
-    ConfigLoaderUtils.quickLoad = quickLoad;
-    /**
-     * Get resolved path from configuration
-     */
-    async function getResolvedPath(pathKey, projectRoot) {
-        const loader = ConfigLoader.getInstance();
-        const result = await loader.load({ projectRoot });
-        // Parse path key (e.g., "docs.adr" or "ginko.sessions")
-        const [category, key] = pathKey.split('.');
-        if (!category || !key) {
-            throw new Error(`Invalid path key: ${pathKey}. Expected format: "category.key"`);
-        }
-        const pathTemplate = result.config.paths[category]?.[key];
-        if (!pathTemplate) {
-            throw new Error(`Path not found: ${pathKey}`);
-        }
-        const resolved = result.resolver.resolve(pathTemplate);
-        if (!resolved.success) {
-            throw new Error(`Failed to resolve path ${pathKey}: ${resolved.errors.join(', ')}`);
-        }
-        return resolved.resolved;
-    }
-    ConfigLoaderUtils.getResolvedPath = getResolvedPath;
-    /**
-     * Check if a feature is enabled
-     */
-    async function isFeatureEnabled(feature, projectRoot) {
-        const config = await quickLoad(projectRoot);
-        return config.features[feature] === true;
-    }
-    ConfigLoaderUtils.isFeatureEnabled = isFeatureEnabled;
-    /**
-     * Update a single configuration value
-     */
-    async function updateConfig(updates, projectRoot) {
-        const loader = ConfigLoader.getInstance();
-        const result = await loader.load({ projectRoot });
-        const updatedConfig = {
-            ...result.config,
-            ...updates,
-            metadata: {
-                ...result.config.metadata,
-                updatedAt: new Date().toISOString()
-            }
-        };
-        await loader.save(updatedConfig, { projectRoot });
-    }
-    ConfigLoaderUtils.updateConfig = updateConfig;
-})(ConfigLoaderUtils || (ConfigLoaderUtils = {}));
-//# sourceMappingURL=config-loader.js.map