pumuki-ast-hooks 5.3.1

package/scripts/hooks-system/application/services/installation/HookInstaller.js

@@ -0,0 +1,197 @@
+const fs = require('fs');
+const path = require('path');
+
+class HookInstaller {
+    constructor(targetRoot, hookSystemRoot, logger = null) {
+        this.targetRoot = targetRoot;
+        this.hookSystemRoot = hookSystemRoot;
+        this.logger = logger;
+        this.COLORS = {
+            reset: '\x1b[0m',
+            green: '\x1b[32m',
+            yellow: '\x1b[33m',
+            cyan: '\x1b[36m'
+        };
+    }
+
+    install(platforms) {
+        const claudeDir = path.join(this.targetRoot, '.ast-intelligence');
+        const claudeSkillsDir = path.join(claudeDir, 'skills');
+        const claudeHooksDir = path.join(claudeDir, 'hooks');
+        const cursorSettingsPath = path.join(this.targetRoot, '.cursor', 'settings.json');
+
+        if (!fs.existsSync(claudeDir)) {
+            fs.mkdirSync(claudeDir, { recursive: true });
+        }
+
+        this.copyIDERules();
+        this.installSkills(claudeSkillsDir, platforms);
+        this.installHooks(claudeHooksDir);
+        this.configureCursorSettings(cursorSettingsPath, claudeHooksDir);
+    }
+
+    installSkills(claudeSkillsDir, platforms) {
+        const librarySkillsDir = path.join(this.hookSystemRoot, 'skills');
+
+        if (!fs.existsSync(librarySkillsDir)) {
+            return;
+        }
+
+        const relevantSkills = this.getRelevantSkills(platforms);
+
+        relevantSkills.forEach(skillName => {
+            const sourceSkillDir = path.join(librarySkillsDir, skillName);
+            const targetSkillDir = path.join(claudeSkillsDir, skillName);
+
+            if (fs.existsSync(sourceSkillDir)) {
+                this.copyRecursive(sourceSkillDir, targetSkillDir);
+                this.logSuccess(`Installed skill: ${skillName}`);
+            }
+        });
+
+        const skillRulesPath = path.join(librarySkillsDir, 'skill-rules.json');
+        if (fs.existsSync(skillRulesPath)) {
+            const targetRulesPath = path.join(claudeSkillsDir, 'skill-rules.json');
+            fs.copyFileSync(skillRulesPath, targetRulesPath);
+            this.logSuccess('Installed skill-rules.json');
+        }
+    }
+
+    installHooks(claudeHooksDir) {
+        const libraryHooksDir = path.join(this.hookSystemRoot, 'hooks');
+
+        if (!fs.existsSync(libraryHooksDir)) {
+            return;
+        }
+
+        if (!fs.existsSync(claudeHooksDir)) {
+            fs.mkdirSync(claudeHooksDir, { recursive: true });
+        }
+
+        const hooksToCopy = [
+            'skill-activation-prompt.ts',
+            'skill-activation-prompt.sh',
+            'pre-tool-use-guard.ts',
+            'pre-tool-use-evidence-validator.ts',
+            'post-tool-use-tracker.sh',
+            'git-status-monitor.ts',
+            'notify-macos.ts',
+            'getSkillRulesPath.ts'
+        ];
+
+        hooksToCopy.forEach(hookFile => {
+            const sourceHook = path.join(libraryHooksDir, hookFile);
+            const targetHook = path.join(claudeHooksDir, hookFile);
+
+            if (fs.existsSync(sourceHook)) {
+                fs.copyFileSync(sourceHook, targetHook);
+                if (hookFile.endsWith('.sh')) {
+                    fs.chmodSync(targetHook, '755');
+                }
+                this.logSuccess(`Installed hook: ${hookFile}`);
+            }
+        });
+
+        const hooksPackageJson = path.join(libraryHooksDir, 'package.json');
+        if (fs.existsSync(hooksPackageJson)) {
+            const targetPackageJson = path.join(claudeHooksDir, 'package.json');
+            fs.copyFileSync(hooksPackageJson, targetPackageJson);
+        }
+    }
+
+    copyIDERules() {
+        const sourceRulesDir = path.join(this.hookSystemRoot, '.cursor', 'rules');
+
+        if (!fs.existsSync(sourceRulesDir)) {
+            return;
+        }
+
+        const ideTargets = [
+            { name: 'Cursor', dir: path.join(this.targetRoot, '.cursor', 'rules') },
+            { name: 'Windsurf', dir: path.join(this.targetRoot, '.windsurf', 'rules') }
+        ];
+
+        ideTargets.forEach(ide => {
+            if (!fs.existsSync(ide.dir)) {
+                fs.mkdirSync(ide.dir, { recursive: true });
+            }
+
+            const ruleFiles = fs.readdirSync(sourceRulesDir).filter(f => f.endsWith('.mdc'));
+            ruleFiles.forEach(ruleFile => {
+                const sourcePath = path.join(sourceRulesDir, ruleFile);
+                const targetPath = path.join(ide.dir, ruleFile);
+                fs.copyFileSync(sourcePath, targetPath);
+            });
+
+            this.logSuccess(`Copied ${ruleFiles.length} rules to ${ide.name}`);
+        });
+    }
+
+    getRelevantSkills(platforms) {
+        const allSkills = ['backend-guidelines', 'frontend-guidelines', 'ios-guidelines', 'android-guidelines'];
+        const relevantSkills = [];
+
+        if (platforms.includes('backend')) relevantSkills.push('backend-guidelines');
+        if (platforms.includes('frontend')) relevantSkills.push('frontend-guidelines');
+        if (platforms.includes('ios')) relevantSkills.push('ios-guidelines');
+        if (platforms.includes('android')) relevantSkills.push('android-guidelines');
+
+        return relevantSkills.length > 0 ? relevantSkills : allSkills;
+    }
+
+    configureCursorSettings(cursorSettingsPath, hooksDir) {
+        const hooksDirRelative = path.relative(this.targetRoot, hooksDir);
+
+        let settings = {};
+        if (fs.existsSync(cursorSettingsPath)) {
+            try {
+                settings = JSON.parse(fs.readFileSync(cursorSettingsPath, 'utf8'));
+            } catch (err) {
+                this.logWarning('Could not parse existing .cursor/settings.json');
+                if (this.logger && this.logger.debug) {
+                    this.logger.debug('CURSOR_SETTINGS_PARSE_ERROR', { error: err.message, path: cursorSettingsPath });
+                }
+            }
+        }
+
+        if (!settings.hooks) {
+            settings.hooks = {};
+        }
+
+        settings.hooks.UserPromptSubmit = path.join(hooksDirRelative, 'skill-activation-prompt.sh');
+        settings.hooks.PreToolUse = [
+            path.join(hooksDirRelative, 'pre-tool-use-evidence-validator.ts'),
+            path.join(hooksDirRelative, 'pre-tool-use-guard.ts')
+        ];
+        settings.hooks.PostToolUse = [
+            path.join(hooksDirRelative, 'post-tool-use-tracker.sh'),
+            path.join(hooksDirRelative, 'git-status-monitor.ts')
+        ];
+
+        const cursorDir = path.dirname(cursorSettingsPath);
+        if (!fs.existsSync(cursorDir)) {
+            fs.mkdirSync(cursorDir, { recursive: true });
+        }
+
+        fs.writeFileSync(cursorSettingsPath, JSON.stringify(settings, null, 2));
+        this.logSuccess('Configured .cursor/settings.json');
+    }
+
+    copyRecursive(source, dest) {
+        if (fs.statSync(source).isDirectory()) {
+            if (!fs.existsSync(dest)) {
+                fs.mkdirSync(dest, { recursive: true });
+            }
+            fs.readdirSync(source).forEach(file => {
+                this.copyRecursive(path.join(source, file), path.join(dest, file));
+            });
+        } else {
+            fs.copyFileSync(source, dest);
+        }
+    }
+
+    logSuccess(msg) { process.stdout.write(`${this.COLORS.green}✓ ${msg}${this.COLORS.reset}\n`); }
+    logWarning(msg) { process.stdout.write(`${this.COLORS.yellow}⚠️  ${msg}${this.COLORS.reset}\n`); }
+}
+
+module.exports = HookInstaller;

package/scripts/hooks-system/application/services/installation/IdeIntegrationService.js

@@ -0,0 +1,37 @@
+const McpConfigurator = require('./McpConfigurator');
+const HookInstaller = require('./HookInstaller');
+const VSCodeTaskConfigurator = require('./VSCodeTaskConfigurator');
+
+const COLORS = {
+    reset: '\x1b[0m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    cyan: '\x1b[36m'
+};
+
+class IdeIntegrationService {
+    constructor(targetRoot, hookSystemRoot, logger = null) {
+        this.targetRoot = targetRoot || process.cwd();
+        this.hookSystemRoot = hookSystemRoot;
+        this.logger = logger;
+
+        this.mcpConfigurator = new McpConfigurator(this.targetRoot, this.hookSystemRoot, this.logger);
+        this.hookInstaller = new HookInstaller(this.targetRoot, this.hookSystemRoot, this.logger);
+        this.vscodeConfigurator = new VSCodeTaskConfigurator(this.targetRoot, this.logger);
+    }
+
+    installCursorHooks(platforms) {
+        this.hookInstaller.install(platforms);
+        this.mcpConfigurator.configure();
+    }
+
+    configureVSCodeTasks() {
+        this.vscodeConfigurator.configure();
+    }
+
+    logSuccess(msg) { process.stdout.write(`${COLORS.green}✓ ${msg}${COLORS.reset}\n`); }
+    logWarning(msg) { process.stdout.write(`${COLORS.yellow}⚠️  ${msg}${COLORS.reset}\n`); }
+    logInfo(msg) { process.stdout.write(`${COLORS.cyan}ℹ️  ${msg}${COLORS.reset}\n`); }
+}
+
+module.exports = IdeIntegrationService;

package/scripts/hooks-system/application/services/installation/InstallService.js

@@ -0,0 +1,130 @@
+const path = require('path');
+const fs = require('fs');
+
+const GitEnvironmentService = require('./GitEnvironmentService');
+const PlatformDetectorService = require('./PlatformDetectorService');
+const FileSystemInstallerService = require('./FileSystemInstallerService');
+const ConfigurationGeneratorService = require('./ConfigurationGeneratorService');
+const IdeIntegrationService = require('./IdeIntegrationService');
+const UnifiedLogger = require('../logging/UnifiedLogger');
+
+const COLORS = {
+    reset: '\x1b[0m',
+    blue: '\x1b[34m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    red: '\x1b[31m',
+    cyan: '\x1b[36m'
+};
+
+class InstallService {
+    constructor() {
+        this.targetRoot = process.cwd();
+        // Assuming this script is located at scripts/hooks-system/application/services/installation/InstallService.js
+        this.hookSystemRoot = path.resolve(__dirname, '../../../');
+
+        // Initialize Audit Logger
+        const auditLogPath = path.join(this.targetRoot, '.audit-reports', 'install.log');
+        if (!fs.existsSync(path.dirname(auditLogPath))) {
+            fs.mkdirSync(path.dirname(auditLogPath), { recursive: true });
+        }
+
+        this.logger = new UnifiedLogger({
+            component: 'Installer',
+            console: { enabled: false }, // Keep console clean for CLI wizard
+            file: {
+                enabled: true,
+                path: auditLogPath,
+                level: 'info'
+            }
+        });
+
+        this.gitService = new GitEnvironmentService(this.targetRoot);
+        this.platformService = new PlatformDetectorService(this.targetRoot);
+        this.fsInstaller = new FileSystemInstallerService(this.targetRoot, this.hookSystemRoot, this.logger);
+        this.configGenerator = new ConfigurationGeneratorService(this.targetRoot, this.hookSystemRoot);
+        this.ideIntegration = new IdeIntegrationService(this.targetRoot, this.hookSystemRoot, this.logger);
+    }
+
+    async run() {
+        this.logger.info('INSTALLATION_STARTED', { targetRoot: this.targetRoot });
+        this.printHeader();
+
+        this.logStep('0/8', 'Checking Git repository...');
+        if (!this.gitService.checkGitRepository()) {
+            this.logError('Git repository check failed');
+            this.logWarning('Installation aborted. Please initialize Git first.');
+            this.logger.error('INSTALLATION_ABORTED', { reason: 'No git repository' });
+            process.exit(1);
+        }
+        this.logSuccess('Git repository detected');
+
+        this.logStep('0.5/8', 'Configuring artifact exclusions...');
+        this.gitService.ensureGitInfoExclude();
+
+        this.logStep('1/8', 'Detecting project platforms...');
+        const platforms = this.platformService.detect();
+        this.logSuccess(`Detected: ${platforms.join(', ')}`);
+        this.logger.info('PLATFORMS_DETECTED', { platforms });
+
+        this.logStep('2/8', 'Installing ESLint configurations...');
+        this.configGenerator.installESLintConfigs();
+
+        this.logStep('3/8', 'Creating hooks-system directory structure...');
+        this.fsInstaller.createDirectoryStructure();
+
+        this.logStep('4/8', 'Copying AST Intelligence system files...');
+        this.fsInstaller.copySystemFiles();
+        this.fsInstaller.copyManageLibraryScript();
+
+        this.logStep('5/8', 'Creating project configuration...');
+        this.configGenerator.createProjectConfig(platforms);
+
+        this.logStep('6/8', 'Installing MCP servers for agentic IDEs...');
+        this.ideIntegration.installCursorHooks(platforms);
+        this.logSuccess('MCP servers installed');
+
+        this.logStep('7/8', 'Installing Git hooks...');
+        this.gitService.installGitHooks();
+
+        this.logStep('7.5/8', 'Configuring VS Code/Cursor tasks for auto-start...');
+        this.ideIntegration.configureVSCodeTasks();
+
+        this.logStep('8/8', 'Adding npm scripts to package.json...');
+        this.configGenerator.addNpmScripts();
+
+        this.logger.info('INSTALLATION_COMPLETED_SUCCESSFULLY');
+        this.printFooter();
+    }
+
+    printHeader() {
+        process.stdout.write(`${COLORS.blue}
+╔════════════════════════════════════════════════════════════════╗
+║          AST Intelligence Hooks - Installation Wizard          ║
+║                         v5.3.1                                 ║
+╚════════════════════════════════════════════════════════════════╝
+${COLORS.reset}\n`);
+    }
+
+    printFooter() {
+        process.stdout.write(`
+${COLORS.green}✨ Installation Complete! ✨${COLORS.reset}
+
+${COLORS.cyan}Next Steps:${COLORS.reset}
+1. Review generated configuration in ${COLORS.yellow}scripts/hooks-system/config/project.config.json${COLORS.reset}
+2. Run ${COLORS.yellow}./manage-library.sh verify${COLORS.reset} to check installation
+3. Commit the changes: ${COLORS.yellow}git add . && git commit -m "chore: install ast-intelligence-hooks"${COLORS.reset}
+
+${COLORS.blue}Documentation:${COLORS.reset}
+- scripts/hooks-system/docs/guides/getting-started.md
+- scripts/hooks-system/docs/architecture.md
+`);
+    }
+
+    logStep(step, msg) { process.stdout.write(`\n${COLORS.cyan}[${step}] ${msg}${COLORS.reset}\n`); }
+    logSuccess(msg) { process.stdout.write(`${COLORS.green}✓ ${msg}${COLORS.reset}\n`); }
+    logError(msg) { process.stdout.write(`${COLORS.red}✗ ${msg}${COLORS.reset}\n`); }
+    logWarning(msg) { process.stdout.write(`${COLORS.yellow}${msg}${COLORS.reset}\n`); }
+}
+
+module.exports = InstallService;

package/scripts/hooks-system/application/services/installation/McpConfigurator.js

@@ -0,0 +1,172 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const COLORS = {
+    reset: '\x1b[0m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    cyan: '\x1b[36m'
+};
+
+class McpConfigurator {
+    constructor(targetRoot, hookSystemRoot, logger = null) {
+        this.targetRoot = targetRoot;
+        this.hookSystemRoot = hookSystemRoot;
+        this.logger = logger;
+    }
+
+    configure() {
+        if (this.logger) this.logger.info('MCP_CONFIGURATION_STARTED');
+        let nodePath = process.execPath;
+        if (!nodePath || !fs.existsSync(nodePath)) {
+            try {
+                nodePath = execSync('which node', { encoding: 'utf-8' }).trim();
+            } catch (err) {
+                nodePath = 'node';
+            }
+        }
+
+        const mcpConfig = {
+            mcpServers: {
+                'ast-intelligence-automation': {
+                    command: nodePath,
+                    args: [
+                        '${workspaceFolder}/scripts/hooks-system/infrastructure/mcp/ast-intelligence-automation.js'
+                    ],
+                    env: {
+                        REPO_ROOT: '${workspaceFolder}',
+                        AUTO_COMMIT_ENABLED: 'false',
+                        AUTO_PUSH_ENABLED: 'false',
+                        AUTO_PR_ENABLED: 'false'
+                    }
+                }
+            }
+        };
+
+        const ideConfigs = this.detectIDEs();
+        let configuredCount = 0;
+
+        ideConfigs.forEach(ide => {
+            if (!fs.existsSync(ide.configDir)) {
+                fs.mkdirSync(ide.configDir, { recursive: true });
+            }
+
+            const mcpConfigPath = path.join(ide.configDir, 'mcp.json');
+
+            if (!fs.existsSync(mcpConfigPath)) {
+                const configToWrite = ide.name === 'Claude Desktop'
+                    ? this.adaptConfigForClaudeDesktop(mcpConfig)
+                    : mcpConfig;
+
+                fs.writeFileSync(mcpConfigPath, JSON.stringify(configToWrite, null, 2));
+                this.logSuccess(`Configured ${ide.configPath}`);
+                if (this.logger) this.logger.info('MCP_CONFIGURED', { ide: ide.name, path: ide.configPath });
+                configuredCount++;
+            } else {
+                try {
+                    const existing = JSON.parse(fs.readFileSync(mcpConfigPath, 'utf8'));
+                    if (!existing.mcpServers) {
+                        existing.mcpServers = {};
+                    }
+
+                    existing.mcpServers['ast-intelligence-automation'] = mcpConfig.mcpServers['ast-intelligence-automation'];
+
+                    fs.writeFileSync(mcpConfigPath, JSON.stringify(existing, null, 2));
+                    this.logSuccess(`Updated ${ide.configPath} (merged configuration)`);
+                    if (this.logger) this.logger.info('MCP_CONFIG_UPDATED', { ide: ide.name, path: ide.configPath });
+                    configuredCount++;
+                } catch (mergeError) {
+                    this.logWarning(`${ide.configPath} already exists and couldn't be merged, skipping`);
+                    if (this.logger) this.logger.warn('MCP_CONFIG_MERGE_FAILED', { ide: ide.name, error: mergeError.message });
+                }
+            }
+        });
+
+        if (configuredCount === 0 && ideConfigs.length === 0) {
+            this.configureFallback(mcpConfig);
+        }
+    }
+
+    configureFallback(mcpConfig) {
+        const cursorDir = path.join(this.targetRoot, '.cursor');
+        if (!fs.existsSync(cursorDir)) {
+            fs.mkdirSync(cursorDir, { recursive: true });
+        }
+        const fallbackPath = path.join(cursorDir, 'mcp.json');
+        if (!fs.existsSync(fallbackPath)) {
+            fs.writeFileSync(fallbackPath, JSON.stringify(mcpConfig, null, 2));
+            this.logSuccess('Configured .cursor/mcp.json (generic fallback)');
+            this.logInfo('Note: MCP servers work with any MCP-compatible IDE');
+            if (this.logger) this.logger.info('MCP_FALLBACK_CONFIGURED', { path: fallbackPath });
+        } else {
+            try {
+                const existing = JSON.parse(fs.readFileSync(fallbackPath, 'utf8'));
+                if (!existing.mcpServers) {
+                    existing.mcpServers = {};
+                }
+                existing.mcpServers['ast-intelligence-automation'] = mcpConfig.mcpServers['ast-intelligence-automation'];
+                fs.writeFileSync(fallbackPath, JSON.stringify(existing, null, 2));
+                this.logSuccess('Updated .cursor/mcp.json (merged configuration)');
+                if (this.logger) this.logger.info('MCP_FALLBACK_UPDATED', { path: fallbackPath });
+            } catch (mergeError) {
+                this.logWarning('.cursor/mcp.json exists and couldn\'t be merged, skipping');
+                if (this.logger) this.logger.warn('MCP_FALLBACK_MERGE_FAILED', { error: mergeError.message });
+            }
+        }
+    }
+
+    detectIDEs() {
+        const os = require('os');
+        const homeDir = os.homedir();
+        const ideConfigs = [];
+
+        const cursorProjectPath = path.join(this.targetRoot, '.cursor', 'mcp.json');
+        ideConfigs.push({
+            name: 'Cursor',
+            configDir: path.dirname(cursorProjectPath),
+            configPath: '.cursor/mcp.json',
+            type: 'project'
+        });
+
+        let claudeDesktopConfigDir;
+        if (process.platform === 'darwin') {
+            claudeDesktopConfigDir = path.join(homeDir, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+        } else if (process.platform === 'win32') {
+            claudeDesktopConfigDir = path.join(process.env.APPDATA || '', 'Claude', 'claude_desktop_config.json');
+        } else {
+            claudeDesktopConfigDir = path.join(homeDir, '.config', 'claude_desktop_config.json');
+        }
+
+        if (fs.existsSync(path.dirname(claudeDesktopConfigDir))) {
+            ideConfigs.push({
+                name: 'Claude Desktop',
+                configDir: path.dirname(claudeDesktopConfigDir),
+                configPath: claudeDesktopConfigDir,
+                type: 'global'
+            });
+        }
+
+        const windsurfProjectPath = path.join(this.targetRoot, '.windsurf', 'mcp.json');
+        if (fs.existsSync(path.dirname(windsurfProjectPath)) || fs.existsSync(path.join(homeDir, '.windsurf'))) {
+            ideConfigs.push({
+                name: 'Windsurf',
+                configDir: path.dirname(windsurfProjectPath),
+                configPath: '.windsurf/mcp.json',
+                type: 'project'
+            });
+        }
+
+        return ideConfigs;
+    }
+
+    adaptConfigForClaudeDesktop(config) {
+        return config;
+    }
+
+    logSuccess(msg) { process.stdout.write(`${COLORS.green}✓ ${msg}${COLORS.reset}\n`); }
+    logWarning(msg) { process.stdout.write(`${COLORS.yellow}⚠️  ${msg}${COLORS.reset}\n`); }
+    logInfo(msg) { process.stdout.write(`${COLORS.cyan}ℹ️  ${msg}${COLORS.reset}\n`); }
+}
+
+module.exports = McpConfigurator;

package/scripts/hooks-system/application/services/installation/PlatformDetectorService.js

@@ -0,0 +1,36 @@
+const glob = require('glob');
+
+class PlatformDetectorService {
+    constructor(targetRoot) {
+        this.targetRoot = targetRoot || process.cwd();
+        this.platforms = [];
+    }
+
+    detect() {
+        const indicators = {
+            ios: ['**/*.swift', '**/*.xcodeproj', '**/Podfile'],
+            android: ['**/*.kt', '**/*.gradle.kts', '**/AndroidManifest.xml'],
+            backend: ['**/nest-cli.json', '**/tsconfig.json', '**/src/**/controllers'],
+            frontend: ['**/next.config.js', '**/next.config.ts', '**/app/**/page.tsx']
+        };
+
+        Object.entries(indicators).forEach(([platform, patterns]) => {
+            const hasIndicators = patterns.some(pattern => {
+                const files = glob.sync(pattern, { cwd: this.targetRoot });
+                return files.length > 0;
+            });
+
+            if (hasIndicators) {
+                this.platforms.push(platform);
+            }
+        });
+
+        if (this.platforms.length === 0) {
+            this.platforms = ['backend', 'frontend']; // Default
+        }
+
+        return this.platforms;
+    }
+}
+
+module.exports = PlatformDetectorService;

package/scripts/hooks-system/application/services/installation/VSCodeTaskConfigurator.js

@@ -0,0 +1,97 @@
+const fs = require('fs');
+const path = require('path');
+
+class VSCodeTaskConfigurator {
+    constructor(targetRoot, logger = null) {
+        this.targetRoot = targetRoot;
+        this.logger = logger;
+        this.COLORS = {
+            reset: '\x1b[0m',
+            green: '\x1b[32m',
+            yellow: '\x1b[33m',
+            cyan: '\x1b[36m'
+        };
+    }
+
+    configure() {
+        const vscodeDir = path.join(this.targetRoot, '.vscode');
+        const tasksJsonPath = path.join(vscodeDir, 'tasks.json');
+
+        try {
+            if (!fs.existsSync(vscodeDir)) {
+                fs.mkdirSync(vscodeDir, { recursive: true });
+            }
+
+            let tasksJson = {
+                version: '2.0.0',
+                tasks: []
+            };
+
+            if (fs.existsSync(tasksJsonPath)) {
+                try {
+                    const content = fs.readFileSync(tasksJsonPath, 'utf8');
+                    tasksJson = JSON.parse(content);
+                    if (!tasksJson.tasks) {
+                        tasksJson.tasks = [];
+                    }
+                } catch (e) {
+                    if (this.logger && this.logger.debug) {
+                        this.logger.debug('VSCODE_TASKS_PARSE_ERROR', { error: e.message, path: tasksJsonPath });
+                    }
+                    // Fallback to default empty structure if parse fails
+                    tasksJson = {
+                        version: '2.0.0',
+                        tasks: []
+                    };
+                }
+            }
+
+            const existingTaskIndex = tasksJson.tasks.findIndex(
+                task => task.label === 'AST Session Loader' || task.identifier === 'ast-session-loader'
+            );
+
+            let sessionLoaderPath = path.join(this.targetRoot, 'scripts', 'hooks-system', 'bin', 'session-loader.sh');
+            const npmPackagePath = path.join(this.targetRoot, 'node_modules', '@pumuki', 'ast-intelligence-hooks', 'bin', 'session-loader.sh');
+
+            if (fs.existsSync(npmPackagePath)) {
+                sessionLoaderPath = npmPackagePath;
+            }
+
+            const sessionLoaderTask = {
+                label: 'AST Session Loader',
+                type: 'shell',
+                command: 'bash',
+                args: [sessionLoaderPath],
+                problemMatcher: [],
+                runOptions: {
+                    runOn: 'folderOpen'
+                },
+                presentation: {
+                    reveal: 'always',
+                    panel: 'new'
+                },
+                identifier: 'ast-session-loader'
+            };
+
+            if (existingTaskIndex >= 0) {
+                tasksJson.tasks[existingTaskIndex] = sessionLoaderTask;
+            } else {
+                tasksJson.tasks.unshift(sessionLoaderTask);
+            }
+
+            fs.writeFileSync(tasksJsonPath, JSON.stringify(tasksJson, null, 2) + '\n');
+            this.logSuccess('Configured VS Code tasks');
+
+        } catch (error) {
+            this.logWarning(`Could not configure VS Code tasks: ${error.message}`);
+            if (this.logger && this.logger.error) {
+                this.logger.error('VSCODE_TASKS_CONFIG_FAILED', { error: error.message });
+            }
+        }
+    }
+
+    logSuccess(msg) { process.stdout.write(`${this.COLORS.green}✓ ${msg}${this.COLORS.reset}\n`); }
+    logWarning(msg) { process.stdout.write(`${this.COLORS.yellow}⚠️  ${msg}${this.COLORS.reset}\n`); }
+}
+
+module.exports = VSCodeTaskConfigurator;