@polymorphism-tech/morph-spec 4.3.7 → 4.6.0

package/src/commands/project/init.js

@@ -4,7 +4,6 @@ import ora from 'ora';
 import chalk from 'chalk';
 import { logger } from '../../utils/logger.js';
 import {
-  getContentDir,
   copyDirectory,
   copyFile,
   pathExists,
@@ -13,20 +12,29 @@ import {
   ensureDir,
   writeFile,
   readFile,
-  updateGitignore,
-  createSymlink,
-  createDirectoryLink
+  updateGitignore
 } from '../../utils/file-copier.js';
 import { saveProjectMorphVersion, getInstalledCLIVersion } from '../../utils/version-checker.js';
-import { installClaudeHooks } from '../../utils/hooks-installer.js';
+import { installClaudeHooks, installGlobalStatusline } from '../../utils/claude-settings-manager.js';
+import { installSkills } from '../../utils/skills-installer.js';
+import { installAgents, installDomainAgents } from '../../utils/agents-installer.js';
 import { AutoContextOrchestrator } from '../../core/orchestrator.js';
 import { detectClaudeCode } from '../../llm/environment-detector.js';
 import inquirer from 'inquirer';
 import { detectProject } from '../../lib/detectors/index.js';
+import { detectClaudeConfig, mapMcpsToPhases, formatConfigSummary } from '../../lib/detectors/claude-config-detector.js';
+import { generateSettings, saveIntegrations } from '../../lib/generators/settings-generator.js';
+import {
+  orchestrateMcpSetup,
+  installAutoMcps,
+  installMcpWithCredentials,
+  generateSetupInstructions,
+  formatMcpStatusTable
+} from '../../lib/installers/mcp-installer.js';
 
 export async function initCommand(options) {
   const targetPath = options.path || process.cwd();
-  const claudeMdPath = join(import.meta.dirname, '..', '..', '..', 'CLAUDE.md');
+  const claudeMdPath = join(import.meta.dirname, '..', '..', '..', 'framework', 'CLAUDE.md');
 
   logger.header('MORPH-SPEC Framework Installation');
   logger.dim(`Target: ${targetPath}`);
@@ -62,12 +70,14 @@ export async function initCommand(options) {
 
     // 2. Create .morph directory structure
     spinner.text = 'Creating .morph structure...';
-    const projectPath = join(morphPath, 'project');
     const configDir = join(morphPath, 'config');
-    await ensureDir(join(projectPath, 'context'));
-    await ensureDir(join(projectPath, 'standards'));
-    await ensureDir(join(projectPath, 'outputs'));
+    const frameworkDestDir = join(morphPath, 'framework');
+    const contextDir = join(morphPath, 'context');
+    const featuresDir = join(morphPath, 'features');
+    await ensureDir(contextDir);
+    await ensureDir(featuresDir);
     await ensureDir(configDir);
+    await ensureDir(frameworkDestDir);
 
     // 3. Create config.json
     spinner.text = 'Generating config.json...';
@@ -87,7 +97,7 @@ export async function initCommand(options) {
 
     // 4. Create context/README.md
     spinner.text = 'Creating context README...';
-    const contextReadme = join(projectPath, 'context', 'README.md');
+    const contextReadme = join(contextDir, 'README.md');
     const readmeContent = `# ${dirName} - Project Context
 
 ## Overview
@@ -109,9 +119,8 @@ Run \`morph-spec detect\` to analyze your project.
     await writeFile(contextReadme, readmeContent);
 
     // 5. Copy framework templates (project-local overrides start from framework defaults)
-    const contentDir = getContentDir();
     const frameworkTemplatesSrc = join(import.meta.dirname, '..', '..', '..', 'framework', 'templates');
-    const templatesDest = join(morphPath, 'templates');
+    const templatesDest = join(frameworkDestDir, 'templates');
     let templatesCopied = false;
     if (await pathExists(frameworkTemplatesSrc)) {
       await copyDirectory(frameworkTemplatesSrc, templatesDest);
@@ -123,7 +132,7 @@ Run \`morph-spec detect\` to analyze your project.
     // 6b. Copy framework standards hierarchy (universal standards)
     spinner.text = 'Copying framework standards hierarchy...';
     const frameworkStandardsSrc = join(import.meta.dirname, '..', '..', '..', 'framework', 'standards');
-    const frameworkStandardsDest = join(morphPath, 'standards');
+    const frameworkStandardsDest = join(frameworkDestDir, 'standards');
     if (await pathExists(frameworkStandardsSrc)) {
       // Copy entire hierarchy (core/, backend/, frontend/, infrastructure/)
       await copyDirectory(frameworkStandardsSrc, frameworkStandardsDest);
@@ -133,32 +142,17 @@ Run \`morph-spec detect\` to analyze your project.
     // 7. Copy agents.json (sourced from framework/ — canonical single source of truth)
     spinner.text = 'Copying agents configuration...';
     const agentsSrc = join(import.meta.dirname, '..', '..', '..', 'framework', 'agents.json');
-    const agentsDest = join(configDir, 'agents.json');
+    const agentsDest = join(frameworkDestDir, 'agents.json');
     if (await pathExists(agentsSrc)) {
       await copyFile(agentsSrc, agentsDest);
     }
 
-    // 8. Copy azure-pricing files
-    spinner.text = 'Copying Azure pricing data...';
-    const pricingSrc = join(contentDir, '.morph', 'config', 'azure-pricing.json');
-    const pricingDest = join(configDir, 'azure-pricing.json');
-    if (await pathExists(pricingSrc)) {
-      await copyFile(pricingSrc, pricingDest);
-    }
-    const pricingSchemaSrc = join(contentDir, '.morph', 'config', 'azure-pricing.schema.json');
-    const pricingSchemaDest = join(configDir, 'azure-pricing.schema.json');
-    if (await pathExists(pricingSchemaSrc)) {
-      await copyFile(pricingSchemaSrc, pricingSchemaDest);
-    }
-
-    // 9. Copy .claude commands and create symlinks for skills
+    // 8. Copy .claude commands and install skills
     // Source: framework/ (canonical for all stacks)
     spinner.text = 'Setting up Claude Code integration...';
     const frameworkDir = join(import.meta.dirname, '..', '..', '..', 'framework');
     const claudeDest = join(targetPath, '.claude');
 
-    let symlinkCount = 0;
-    let copyCount = 0;
     let commandsCopied = false;
 
     // Copy commands directory (slash commands): framework/commands/ → .claude/commands/
@@ -171,58 +165,48 @@ Run \`morph-spec detect\` to analyze your project.
       logger.warn('  ⚠ framework/commands/ source missing — commands not installed');
     }
 
-    // Create directory links for skill categories (or copy if linking fails)
-    // Source: framework/skills/ → .claude/skills/
-    {
-      const skillsSrc = join(frameworkDir, 'skills');
-      const skillsDest = join(claudeDest, 'skills');
-
-      if (await pathExists(skillsSrc)) {
-        await ensureDir(skillsDest);
-
-        const entries = await fs.readdir(skillsSrc, { withFileTypes: true });
-
-        let linkedCategories = 0;
-        let copiedCategories = 0;
-        let totalSkillFiles = 0;
-
-        // Link category directories (specialists/, infra/, checklists/, etc.)
-        for (const entry of entries) {
-          if (entry.isDirectory()) {
-            const categorySrc = join(skillsSrc, entry.name);
-            const categoryDest = join(skillsDest, entry.name);
-
-            // Count .md files for reporting
-            const categoryEntries = await fs.readdir(categorySrc, { withFileTypes: true });
-            const mdFiles = categoryEntries.filter(e => e.isFile() && e.name.endsWith('.md'));
-            totalSkillFiles += mdFiles.length;
-
-            const result = await createDirectoryLink(categorySrc, categoryDest);
-            if (result === 'copy') {
-              copiedCategories++;
-            } else {
-              linkedCategories++;
-            }
-          } else if (entry.isFile() && entry.name.endsWith('.md')) {
-            // Handle .md files in skills root
-            totalSkillFiles++;
-            const result = await createSymlink(join(skillsSrc, entry.name), join(skillsDest, entry.name), 'file');
-            if (result === 'symlink') {
-              linkedCategories++;
-            } else {
-              copiedCategories++;
-            }
-          }
-        }
+    // 9a. Install path-scoped rules to .claude/rules/ (native Claude Code pattern)
+    spinner.text = 'Installing path-scoped rules to .claude/rules/...';
+    const rulesSrc = join(frameworkDir, 'rules');
+    const rulesDest = join(claudeDest, 'rules');
+    let rulesCopied = false;
+    if (await pathExists(rulesSrc)) {
+      await copyDirectory(rulesSrc, rulesDest);
+      rulesCopied = true;
+    }
 
-        symlinkCount = linkedCategories > 0 ? totalSkillFiles : 0;
-        copyCount = linkedCategories === 0 ? totalSkillFiles : 0;
-      }
+    // 9b. Install morph skills to .claude/skills/ for native Claude Code discovery
+    spinner.text = 'Installing morph skills to .claude/skills/...';
+    await installSkills(targetPath);
+
+    // 9b2. Install tier-1/2 agents as native Claude Code subagents in .claude/agents/
+    spinner.text = 'Installing native subagents to .claude/agents/...';
+    await installAgents(targetPath, frameworkDir);
+
+    // 9b2b. Install level-2 domain agents as native Claude Code subagents in .claude/agents/
+    await installDomainAgents(targetPath, frameworkDir);
+
+    // 9b3. Install runtime CLAUDE.md to .claude/CLAUDE.md (Claude Code runtime instructions)
+    spinner.text = 'Installing .claude/CLAUDE.md...';
+    const runtimeClaudeMdSrc = join(frameworkDir, 'CLAUDE.md');
+    const runtimeClaudeMdDest = join(claudeDest, 'CLAUDE.md');
+    if (await pathExists(runtimeClaudeMdSrc)) {
+      await copyFile(runtimeClaudeMdSrc, runtimeClaudeMdDest);
     }
 
-    // 9b. Install/update agent-teams hooks in .claude/settings.local.json
+    // 9c. Install statusline globally to ~/.claude/ (applies to all Claude Code sessions)
+    spinner.text = 'Installing statusline globally to ~/.claude/...';
+    const HOOKS_SRC = join(import.meta.dirname, '..', '..', '..', 'framework', 'hooks', 'claude-code');
+    try {
+      await installGlobalStatusline(HOOKS_SRC);
+    } catch {
+      // Non-critical: global dir may not be writable in all environments
+      logger.dim('  ⚠ Could not install statusline globally (non-critical)');
+    }
+
+    // 9d. Install/update Claude Code hooks in .claude/settings.local.json
     spinner.text = 'Installing Claude Code hooks...';
-    const hooksInstalled = await installClaudeHooks(targetPath);
+    const hooksResult = await installClaudeHooks(targetPath);
 
     // 10. Save version info
     spinner.text = 'Saving version info...';
@@ -233,89 +217,281 @@ Run \`morph-spec detect\` to analyze your project.
     spinner.text = 'Updating .gitignore...';
     await updateGitignore(targetPath);
 
-    spinner.succeed('MORPH-SPEC installed successfully!');
+    // 11b. Detect Claude Code environment (plugins, MCPs, skills)
+    spinner.text = 'Detecting Claude Code environment...';
+    let claudeConfigDetected = null;
+    let integrationsCreated = false;
+    try {
+      claudeConfigDetected = await detectClaudeConfig(targetPath);
+      const hasIntegrations = claudeConfigDetected.plugins.length > 0
+        || claudeConfigDetected.mcpServers.length > 0
+        || claudeConfigDetected.superpowers.installed;
+
+      if (hasIntegrations) {
+        spinner.stop();
+        logger.blank();
+        logger.header('Claude Code Environment Detected');
+
+        const summary = formatConfigSummary(claudeConfigDetected);
+        if (summary) {
+          logger.info(summary);
+        }
 
-    // Show next steps
-    logger.blank();
-    logger.success(`MORPH-SPEC v${cliVersion} installed successfully!`);
-    logger.blank();
-    logger.header('Next Steps');
+        // Show MCP-to-phase mapping
+        if (claudeConfigDetected.mcpServers.length > 0) {
+          const phaseMap = mapMcpsToPhases(claudeConfigDetected.mcpServers);
+          logger.blank();
+          logger.dim('MCP usage by phase:');
+          for (const [phase, mcps] of Object.entries(phaseMap)) {
+            if (mcps.length > 0) {
+              logger.dim(`  ${phase}: ${mcps.map(m => m.name).join(', ')}`);
+            }
+          }
+        }
 
-    logger.step(1, 'Run detection: morph-spec detect');
-    logger.step(2, 'Review .morph/config.json and .morph/project/standards/inferred.md');
-    logger.step(3, 'Open project in VS Code with Claude Code');
-    logger.step(4, 'Start your first feature:');
-    logger.blank();
-    logger.box([
-      'Ask Claude Code to implement a feature'
-    ]);
-    logger.blank();
+        logger.blank();
+        const { saveIntegrationsChoice } = await inquirer.prompt([{
+          type: 'confirm',
+          name: 'saveIntegrationsChoice',
+          message: 'Save detected integrations and generate optimized settings?',
+          default: true
+        }]);
 
-    logger.info('Files installed:');
-    logger.dim(`  ✓ CLAUDE.md`);
-    logger.dim(`  ✓ .morph/config/ (config.json, agents.json, azure-pricing.json)`);
-    logger.dim(`  ✓ .morph/standards/ (coding.md, architecture.md, azure.md, ...)`);
-    if (templatesCopied) {
-      logger.dim(`  ✓ .morph/templates/ (project-local overrides for framework templates)`);
-    }
-    logger.dim(`  ✓ .morph/project/ (context, standards, outputs)`);
-    if (commandsCopied) {
-      logger.dim(`  ✓ .claude/commands/ (slash commands)`);
-    }
-    logger.dim(`  ✓ .claude/settings.local.json (agent-teams hooks)`);
-
-    if (symlinkCount > 0) {
-      const linkType = process.platform === 'win32' ? 'junction-linked' : 'symlinked';
-      logger.dim(`  ✓ .claude/skills/ (${symlinkCount} ${linkType})`);
-    } else if (copyCount > 0) {
-      logger.dim(`  ✓ .claude/skills/ (${copyCount} copied)`);
-      logger.warn(`  ⚠ Directory links not supported (copied instead). Skills won't auto-update.`);
+        if (saveIntegrationsChoice) {
+          spinner.start('Saving integrations...');
+          await saveIntegrations(targetPath, claudeConfigDetected);
+          await generateSettings(targetPath, claudeConfigDetected, config);
+          integrationsCreated = true;
+          spinner.succeed('Integrations saved to .morph/config/integrations.json');
+        } else {
+          spinner.start('Continuing...');
+        }
+      }
+    } catch (error) {
+      // Non-fatal: continue without integrations
+      logger.dim(`  Claude config detection skipped: ${error.message}`);
     }
 
-    logger.blank();
-
-    // 12. Interactive stack/standards detection for existing projects
+    // 11c. Stack detection (moved before MCP setup so we know the stack)
+    spinner.text = 'Detecting project stack...';
+    let detectedStack = 'unknown';
     const hasProjectFiles = await pathExists(join(targetPath, 'package.json'))
       || await pathExists(join(targetPath, 'src'))
       || (await fs.readdir(targetPath)).some(f => f.endsWith('.csproj'));
 
     if (hasProjectFiles) {
-      logger.blank();
-      logger.header('Existing Project Detected');
-
       try {
         const quickResults = await detectProject(targetPath, { conversation: false, generateStandards: false });
         const structure = quickResults.structure;
 
         if (structure?.stack && structure.stack !== 'unknown') {
+          detectedStack = structure.stack;
+          spinner.stop();
+          logger.blank();
+          logger.header('Existing Project Detected');
           logger.info(`Stack detected: ${structure.stack}`);
           if (structure?.architecture) logger.dim(`Architecture: ${structure.architecture}`);
           if (structure?.uiLibrary) logger.dim(`UI Library: ${structure.uiLibrary}`);
+
+          const { standardsChoice } = await inquirer.prompt([{
+            type: 'list',
+            name: 'standardsChoice',
+            message: 'How should morph-spec handle your project standards?',
+            choices: [
+              { name: 'Keep morph-spec defaults (recommended)', value: 'morph-spec' },
+              { name: 'Detect project-specific standards', value: 'detect' }
+            ]
+          }]);
+
+          if (standardsChoice === 'detect') {
+            spinner.start('Generating project-specific standards...');
+            const fullResults = await detectProject(targetPath, { conversation: false });
+            const inferredPath = join(contextDir, 'standards.md');
+            await writeFile(inferredPath, fullResults.inferred.markdown);
+            spinner.succeed('Generated .morph/context/standards.md');
+            logger.dim('Review and edit .morph/context/standards.md as needed.');
+          }
+
+          spinner.start('Continuing...');
         }
+      } catch (error) {
+        logger.dim(`  Stack detection skipped: ${error.message}`);
+      }
+    }
 
-        const { standardsChoice } = await inquirer.prompt([{
-          type: 'list',
-          name: 'standardsChoice',
-          message: 'How should morph-spec handle your project standards?',
-          choices: [
-            { name: 'Keep morph-spec defaults (recommended)', value: 'morph-spec' },
-            { name: 'Detect project-specific standards', value: 'detect' }
-          ]
-        }]);
+    // 11d. MCP Auto-Setup
+    let mcpSetupResult = null;
+    if (!options.skipMcp) {
+      try {
+        spinner.stop();
+        const existingMcps = claudeConfigDetected?.mcpServers || [];
+        const orchestration = orchestrateMcpSetup(targetPath, detectedStack, existingMcps);
+
+        const autoNames = Object.keys(orchestration.autoInstallable);
+        const manualNames = Object.keys(orchestration.needsManualSetup);
+        const hasAutoMcps = autoNames.length > 0;
+        const hasManualMcps = manualNames.length > 0;
+
+        if (hasAutoMcps || hasManualMcps) {
+          logger.blank();
+          logger.header('MCP Server Setup');
+
+          // Auto-install prompt
+          let autoInstalled = {};
+          if (hasAutoMcps) {
+            const { installAuto } = await inquirer.prompt([{
+              type: 'confirm',
+              name: 'installAuto',
+              message: `Install recommended MCP servers? (${autoNames.join(', ')})`,
+              default: true
+            }]);
+
+            if (installAuto) {
+              spinner.start('Installing MCP servers...');
+              const result = await installAutoMcps(targetPath, orchestration.autoInstallable);
+              spinner.succeed(`Installed ${result.added.length} MCP server(s)`);
+              for (const name of result.added) {
+                autoInstalled[name] = orchestration.autoInstallable[name];
+              }
+            }
+          }
+
+          // Credential MCPs — inline setup or instructions
+          const manualInstalled = {};
+          if (hasManualMcps) {
+            for (const [name, entry] of Object.entries(orchestration.needsManualSetup)) {
+              logger.blank();
+
+              // Show warnings
+              for (const warning of entry.install.warnings || []) {
+                logger.warn(`  ${warning}`);
+              }
+
+              const capitalizedName = name.charAt(0).toUpperCase() + name.slice(1);
+              const { setupNow } = await inquirer.prompt([{
+                type: 'confirm',
+                name: 'setupNow',
+                message: `Set up ${capitalizedName} MCP now? (${entry.usage})`,
+                default: false
+              }]);
+
+              if (setupNow) {
+                // Collect credentials
+                const credentialValues = {};
+                for (const cred of entry.install.credentials) {
+                  const { value } = await inquirer.prompt([{
+                    type: cred.secret ? 'password' : 'input',
+                    name: 'value',
+                    message: `${cred.name}:`,
+                    mask: cred.secret ? '*' : undefined
+                  }]);
+                  credentialValues[cred.envVar] = value;
+                }
+
+                spinner.start(`Configuring ${name}...`);
+                await installMcpWithCredentials(targetPath, name, entry, credentialValues);
+                spinner.succeed(`${capitalizedName} MCP configured`);
+                manualInstalled[name] = entry;
+              } else {
+                // Show setup instructions
+                const instructions = generateSetupInstructions(name, entry);
+                logger.blank();
+                logger.dim('  Add to .claude/settings.local.json → mcpServers:');
+                logger.dim('  ' + '─'.repeat(55));
+                for (const line of instructions.configSnippet.split('\n')) {
+                  logger.dim(`  ${line}`);
+                }
+                logger.dim('  ' + '─'.repeat(55));
+
+                for (const cred of instructions.credentialUrls) {
+                  logger.dim(`  Get ${cred.name}: ${cred.helpUrl}`);
+                }
+                logger.dim(`  Or run later: ${instructions.cliCommand}`);
+              }
+            }
+          }
+
+          // Summary table
+          const justInstalled = { ...autoInstalled, ...manualInstalled };
+          const statusRows = formatMcpStatusTable(orchestration, justInstalled);
+
+          if (statusRows.length > 0) {
+            logger.blank();
+            logger.info('MCP Servers');
+            logger.dim('─'.repeat(60));
+
+            const STATUS_ICONS = {
+              installed: '✓',
+              available: '○',
+              already_configured: '✓',
+              needs_setup: '⚠',
+              prereq_missing: '✗',
+              not_relevant: '─'
+            };
+
+            for (const row of statusRows) {
+              const icon = STATUS_ICONS[row.status] || '?';
+              const statusLabel = row.status.replace(/_/g, ' ');
+              logger.dim(`  ${icon} ${row.name.padEnd(15)} ${statusLabel.padEnd(20)} ${row.detail}`);
+            }
+          }
 
-        if (standardsChoice === 'detect') {
-          spinner.start('Generating project-specific standards...');
-          const fullResults = await detectProject(targetPath, { conversation: false });
-          const inferredPath = join(morphPath, 'project', 'standards', 'inferred.md');
-          await writeFile(inferredPath, fullResults.inferred.markdown);
-          spinner.succeed('Generated .morph/project/standards/inferred.md');
-          logger.dim('Review and edit .morph/project/standards/inferred.md as needed.');
+          mcpSetupResult = { autoInstalled, manualInstalled, orchestration };
         }
       } catch (error) {
-        logger.warn(`Stack detection failed: ${error.message}`);
+        logger.dim(`  MCP setup skipped: ${error.message}`);
+      }
+    } else {
+      logger.dim('\nSkipped MCP setup (--skip-mcp flag)');
+    }
+
+    spinner.succeed('MORPH-SPEC installed successfully!');
+
+    // Show next steps
+    logger.blank();
+    logger.success(`MORPH-SPEC v${cliVersion} installed successfully!`);
+    logger.blank();
+    logger.header('Next Steps');
+
+    logger.step(1, 'Run detection: morph-spec detect');
+    logger.step(2, 'Review .morph/config/config.json and .morph/context/standards.md');
+    logger.step(3, 'Open project in VS Code with Claude Code');
+    logger.step(4, 'Start your first feature:');
+    logger.blank();
+    logger.box([
+      'Ask Claude Code to implement a feature'
+    ]);
+    logger.blank();
+
+    logger.info('Files installed:');
+    logger.dim(`  ✓ CLAUDE.md`);
+    logger.dim(`  ✓ .morph/config/ (config.json)`);
+    logger.dim(`  ✓ .morph/framework/ (agents.json, standards/, templates/)`);
+    logger.dim(`  ✓ .morph/context/ (project context)`);
+    logger.dim(`  ✓ .morph/features/ (feature outputs)`);
+    if (commandsCopied) {
+      logger.dim(`  ✓ .claude/commands/ (slash commands)`);
+    }
+    if (rulesCopied) {
+      logger.dim(`  ✓ .claude/rules/ (5 path-scoped rules)`);
+    }
+    logger.dim(`  ✓ .claude/settings.local.json (${hooksResult.installed} hooks installed)`);
+    if (integrationsCreated) {
+      logger.dim(`  ✓ .morph/config/integrations.json (detected plugins & MCPs)`);
+    }
+    if (mcpSetupResult) {
+      const autoCount = Object.keys(mcpSetupResult.autoInstalled).length;
+      const manualCount = Object.keys(mcpSetupResult.manualInstalled).length;
+      if (autoCount + manualCount > 0) {
+        logger.dim(`  ✓ MCP servers (${autoCount + manualCount} configured)`);
       }
     }
 
+    logger.dim('  ✓ .claude/skills/ (installed as skill directories)');
+    logger.dim('  ✓ .claude/agents/ (native subagents installed)');
+
+    logger.blank();
+
     // 13. LLM-based auto-detect project context (if Claude Code is available and not --skip-detection)
     if (!options.skipDetection && detectClaudeCode()) {
       logger.blank();
@@ -349,6 +525,12 @@ Run \`morph-spec detect\` to analyze your project.
       logger.dim('Run "morph-spec update --wizard" to configure manually.');
     }
 
+    // Suggest tutorial for first-time users
+    if (integrationsCreated) {
+      logger.blank();
+      logger.info('First time using morph-spec? Run `morph-spec tutorial` to get started.');
+    }
+
     logger.blank();
 
   } catch (error) {