claude-flow 3.0.0-alpha.5 → 3.0.0-alpha.63

package/dist/src/init/statusline-generator.js

@@ -0,0 +1,369 @@
+/**
+ * Statusline Configuration Generator
+ * Creates statusline configuration for V3 progress display
+ */
+/**
+ * Generate statusline configuration script
+ * Matches the advanced format:
+ * ▊ Claude Flow V3 ● user  │  ⎇ v3  │  Opus 4.5
+ * ─────────────────────────────────────────────────────
+ * 🏗️  DDD Domains    [●●●●●]  5/5    ⚡ 1.0x → 2.49x-7.47x
+ * 🤖 Swarm  ◉ [12/15]  👥 0    🟢 CVE 3/3    💾 5177MB    📂  56%    🧠  30%
+ * 🔧 Architecture    DDD ●100%  │  Security ●CLEAN  │  Memory ●AgentDB  │  Integration ●
+ */
+export function generateStatuslineScript(options) {
+    const config = options.statusline;
+    // Generate CommonJS script - use .cjs extension for ES module project compatibility
+    return `#!/usr/bin/env node
+/**
+ * Claude Flow V3 Statusline Generator
+ * Displays real-time V3 implementation progress and system status
+ *
+ * Usage: node statusline.cjs [--json] [--compact]
+ *
+ * IMPORTANT: This file uses .cjs extension to work in ES module projects.
+ * The require() syntax is intentional for CommonJS compatibility.
+ */
+
+/* eslint-disable @typescript-eslint/no-var-requires */
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+// Configuration
+const CONFIG = {
+  enabled: ${config.enabled},
+  showProgress: ${config.showProgress},
+  showSecurity: ${config.showSecurity},
+  showSwarm: ${config.showSwarm},
+  showHooks: ${config.showHooks},
+  showPerformance: ${config.showPerformance},
+  refreshInterval: ${config.refreshInterval},
+  maxAgents: ${options.runtime.maxAgents},
+  topology: '${options.runtime.topology}',
+};
+
+// ANSI colors
+const c = {
+  reset: '\\x1b[0m',
+  bold: '\\x1b[1m',
+  dim: '\\x1b[2m',
+  red: '\\x1b[0;31m',
+  green: '\\x1b[0;32m',
+  yellow: '\\x1b[0;33m',
+  blue: '\\x1b[0;34m',
+  purple: '\\x1b[0;35m',
+  cyan: '\\x1b[0;36m',
+  brightRed: '\\x1b[1;31m',
+  brightGreen: '\\x1b[1;32m',
+  brightYellow: '\\x1b[1;33m',
+  brightBlue: '\\x1b[1;34m',
+  brightPurple: '\\x1b[1;35m',
+  brightCyan: '\\x1b[1;36m',
+  brightWhite: '\\x1b[1;37m',
+};
+
+// Get user info
+function getUserInfo() {
+  let name = 'user';
+  let gitBranch = '';
+  let modelName = 'Opus 4.5';
+
+  try {
+    name = execSync('git config user.name 2>/dev/null || echo "user"', { encoding: 'utf-8' }).trim();
+    gitBranch = execSync('git branch --show-current 2>/dev/null || echo ""', { encoding: 'utf-8' }).trim();
+  } catch (e) {
+    // Ignore errors
+  }
+
+  return { name, gitBranch, modelName };
+}
+
+// Get learning stats from memory database
+function getLearningStats() {
+  const memoryPaths = [
+    path.join(process.cwd(), '.swarm', 'memory.db'),
+    path.join(process.cwd(), '.claude', 'memory.db'),
+    path.join(process.cwd(), 'data', 'memory.db'),
+  ];
+
+  let patterns = 0;
+  let sessions = 0;
+  let trajectories = 0;
+
+  // Try to read from sqlite database
+  for (const dbPath of memoryPaths) {
+    if (fs.existsSync(dbPath)) {
+      try {
+        // Count entries in memory file (rough estimate from file size)
+        const stats = fs.statSync(dbPath);
+        const sizeKB = stats.size / 1024;
+        // Estimate: ~2KB per pattern on average
+        patterns = Math.floor(sizeKB / 2);
+        sessions = Math.max(1, Math.floor(patterns / 10));
+        trajectories = Math.floor(patterns / 5);
+        break;
+      } catch (e) {
+        // Ignore
+      }
+    }
+  }
+
+  // Also check for session files
+  const sessionsPath = path.join(process.cwd(), '.claude', 'sessions');
+  if (fs.existsSync(sessionsPath)) {
+    try {
+      const sessionFiles = fs.readdirSync(sessionsPath).filter(f => f.endsWith('.json'));
+      sessions = Math.max(sessions, sessionFiles.length);
+    } catch (e) {
+      // Ignore
+    }
+  }
+
+  return { patterns, sessions, trajectories };
+}
+
+// Get V3 progress from learning state (grows as system learns)
+function getV3Progress() {
+  const learning = getLearningStats();
+
+  // DDD progress based on actual learned patterns
+  // New install: 0 patterns = 0/5 domains, 0% DDD
+  // As patterns grow: 10+ patterns = 1 domain, 50+ = 2, 100+ = 3, 200+ = 4, 500+ = 5
+  let domainsCompleted = 0;
+  if (learning.patterns >= 500) domainsCompleted = 5;
+  else if (learning.patterns >= 200) domainsCompleted = 4;
+  else if (learning.patterns >= 100) domainsCompleted = 3;
+  else if (learning.patterns >= 50) domainsCompleted = 2;
+  else if (learning.patterns >= 10) domainsCompleted = 1;
+
+  const totalDomains = 5;
+  const dddProgress = Math.min(100, Math.floor((domainsCompleted / totalDomains) * 100));
+
+  return {
+    domainsCompleted,
+    totalDomains,
+    dddProgress,
+    patternsLearned: learning.patterns,
+    sessionsCompleted: learning.sessions
+  };
+}
+
+// Get security status based on actual scans
+function getSecurityStatus() {
+  // Check for security scan results in memory
+  const scanResultsPath = path.join(process.cwd(), '.claude', 'security-scans');
+  let cvesFixed = 0;
+  const totalCves = 3;
+
+  if (fs.existsSync(scanResultsPath)) {
+    try {
+      const scans = fs.readdirSync(scanResultsPath).filter(f => f.endsWith('.json'));
+      // Each successful scan file = 1 CVE addressed
+      cvesFixed = Math.min(totalCves, scans.length);
+    } catch (e) {
+      // Ignore
+    }
+  }
+
+  // Also check .swarm/security for audit results
+  const auditPath = path.join(process.cwd(), '.swarm', 'security');
+  if (fs.existsSync(auditPath)) {
+    try {
+      const audits = fs.readdirSync(auditPath).filter(f => f.includes('audit'));
+      cvesFixed = Math.min(totalCves, Math.max(cvesFixed, audits.length));
+    } catch (e) {
+      // Ignore
+    }
+  }
+
+  const status = cvesFixed >= totalCves ? 'CLEAN' : cvesFixed > 0 ? 'IN_PROGRESS' : 'PENDING';
+
+  return {
+    status,
+    cvesFixed,
+    totalCves,
+  };
+}
+
+// Get swarm status
+function getSwarmStatus() {
+  let activeAgents = 0;
+  let coordinationActive = false;
+
+  try {
+    const ps = execSync('ps aux 2>/dev/null | grep -c agentic-flow || echo "0"', { encoding: 'utf-8' });
+    activeAgents = Math.max(0, parseInt(ps.trim()) - 1);
+    coordinationActive = activeAgents > 0;
+  } catch (e) {
+    // Ignore errors
+  }
+
+  return {
+    activeAgents,
+    maxAgents: CONFIG.maxAgents,
+    coordinationActive,
+  };
+}
+
+// Get system metrics (dynamic based on actual state)
+function getSystemMetrics() {
+  let memoryMB = 0;
+  let subAgents = 0;
+
+  try {
+    const mem = execSync('ps aux | grep -E "(node|agentic|claude)" | grep -v grep | awk \\'{sum += \\$6} END {print int(sum/1024)}\\'', { encoding: 'utf-8' });
+    memoryMB = parseInt(mem.trim()) || 0;
+  } catch (e) {
+    // Fallback
+    memoryMB = Math.floor(process.memoryUsage().heapUsed / 1024 / 1024);
+  }
+
+  // Get learning stats for intelligence %
+  const learning = getLearningStats();
+
+  // Intelligence % based on learned patterns (0 patterns = 0%, 1000+ = 100%)
+  const intelligencePct = Math.min(100, Math.floor((learning.patterns / 10) * 1));
+
+  // Context % based on session history (0 sessions = 0%, grows with usage)
+  const contextPct = Math.min(100, Math.floor(learning.sessions * 5));
+
+  // Count active sub-agents from process list
+  try {
+    const agents = execSync('ps aux 2>/dev/null | grep -c "claude-flow.*agent" || echo "0"', { encoding: 'utf-8' });
+    subAgents = Math.max(0, parseInt(agents.trim()) - 1);
+  } catch (e) {
+    // Ignore
+  }
+
+  return {
+    memoryMB,
+    contextPct,
+    intelligencePct,
+    subAgents,
+  };
+}
+
+// Generate progress bar
+function progressBar(current, total) {
+  const width = 5;
+  const filled = Math.round((current / total) * width);
+  const empty = width - filled;
+  return '[' + '\\u25CF'.repeat(filled) + '\\u25CB'.repeat(empty) + ']';
+}
+
+// Generate full statusline
+function generateStatusline() {
+  const user = getUserInfo();
+  const progress = getV3Progress();
+  const security = getSecurityStatus();
+  const swarm = getSwarmStatus();
+  const system = getSystemMetrics();
+  const lines = [];
+
+  // Header Line
+  let header = \`\${c.bold}\${c.brightPurple}▊ Claude Flow V3 \${c.reset}\`;
+  header += \`\${swarm.coordinationActive ? c.brightCyan : c.dim}● \${c.brightCyan}\${user.name}\${c.reset}\`;
+  if (user.gitBranch) {
+    header += \`  \${c.dim}│\${c.reset}  \${c.brightBlue}⎇ \${user.gitBranch}\${c.reset}\`;
+  }
+  header += \`  \${c.dim}│\${c.reset}  \${c.purple}\${user.modelName}\${c.reset}\`;
+  lines.push(header);
+
+  // Separator
+  lines.push(\`\${c.dim}─────────────────────────────────────────────────────\${c.reset}\`);
+
+  // Line 1: DDD Domain Progress
+  const domainsColor = progress.domainsCompleted >= 3 ? c.brightGreen : progress.domainsCompleted > 0 ? c.yellow : c.red;
+  lines.push(
+    \`\${c.brightCyan}🏗️  DDD Domains\${c.reset}    \${progressBar(progress.domainsCompleted, progress.totalDomains)}  \` +
+    \`\${domainsColor}\${progress.domainsCompleted}\${c.reset}/\${c.brightWhite}\${progress.totalDomains}\${c.reset}    \` +
+    \`\${c.brightYellow}⚡ 1.0x\${c.reset} \${c.dim}→\${c.reset} \${c.brightYellow}2.49x-7.47x\${c.reset}\`
+  );
+
+  // Line 2: Swarm + CVE + Memory + Context + Intelligence
+  const swarmIndicator = swarm.coordinationActive ? \`\${c.brightGreen}◉\${c.reset}\` : \`\${c.dim}○\${c.reset}\`;
+  const agentsColor = swarm.activeAgents > 0 ? c.brightGreen : c.red;
+  let securityIcon = security.status === 'CLEAN' ? '🟢' : security.status === 'IN_PROGRESS' ? '🟡' : '🔴';
+  let securityColor = security.status === 'CLEAN' ? c.brightGreen : security.status === 'IN_PROGRESS' ? c.brightYellow : c.brightRed;
+
+  lines.push(
+    \`\${c.brightYellow}🤖 Swarm\${c.reset}  \${swarmIndicator} [\${agentsColor}\${String(swarm.activeAgents).padStart(2)}\${c.reset}/\${c.brightWhite}\${swarm.maxAgents}\${c.reset}]  \` +
+    \`\${c.brightPurple}👥 \${system.subAgents}\${c.reset}    \` +
+    \`\${securityIcon} \${securityColor}CVE \${security.cvesFixed}\${c.reset}/\${c.brightWhite}\${security.totalCves}\${c.reset}    \` +
+    \`\${c.brightCyan}💾 \${system.memoryMB}MB\${c.reset}    \` +
+    \`\${c.brightGreen}📂 \${String(system.contextPct).padStart(3)}%\${c.reset}    \` +
+    \`\${c.dim}🧠 \${String(system.intelligencePct).padStart(3)}%\${c.reset}\`
+  );
+
+  // Line 3: Architecture status
+  const dddColor = progress.dddProgress >= 50 ? c.brightGreen : progress.dddProgress > 0 ? c.yellow : c.red;
+  lines.push(
+    \`\${c.brightPurple}🔧 Architecture\${c.reset}    \` +
+    \`\${c.cyan}DDD\${c.reset} \${dddColor}●\${String(progress.dddProgress).padStart(3)}%\${c.reset}  \${c.dim}│\${c.reset}  \` +
+    \`\${c.cyan}Security\${c.reset} \${securityColor}●\${security.status}\${c.reset}  \${c.dim}│\${c.reset}  \` +
+    \`\${c.cyan}Memory\${c.reset} \${c.brightGreen}●AgentDB\${c.reset}  \${c.dim}│\${c.reset}  \` +
+    \`\${c.cyan}Integration\${c.reset} \${swarm.coordinationActive ? c.brightCyan : c.dim}●\${c.reset}\`
+  );
+
+  return lines.join('\\n');
+}
+
+// Generate JSON data
+function generateJSON() {
+  return {
+    user: getUserInfo(),
+    v3Progress: getV3Progress(),
+    security: getSecurityStatus(),
+    swarm: getSwarmStatus(),
+    system: getSystemMetrics(),
+    performance: {
+      flashAttentionTarget: '2.49x-7.47x',
+      searchImprovement: '150x-12,500x',
+      memoryReduction: '50-75%',
+    },
+    lastUpdated: new Date().toISOString(),
+  };
+}
+
+// Main
+if (process.argv.includes('--json')) {
+  console.log(JSON.stringify(generateJSON(), null, 2));
+} else if (process.argv.includes('--compact')) {
+  console.log(JSON.stringify(generateJSON()));
+} else {
+  console.log(generateStatusline());
+}
+`;
+}
+/**
+ * Generate statusline hook for shell integration
+ */
+export function generateStatuslineHook(options) {
+    if (!options.statusline.enabled) {
+        return '# Statusline disabled';
+    }
+    return `# Claude Flow V3 Statusline Hook
+# Add to your shell RC file (.bashrc, .zshrc, etc.)
+
+# Function to get statusline
+claude_flow_statusline() {
+  local statusline_script="\${CLAUDE_FLOW_DIR:-.claude}/helpers/statusline.cjs"
+  if [ -f "$statusline_script" ]; then
+    node "$statusline_script" 2>/dev/null || echo ""
+  fi
+}
+
+# For bash PS1
+# export PS1='$(claude_flow_statusline) \\n\\$ '
+
+# For zsh RPROMPT
+# export RPROMPT='$(claude_flow_statusline)'
+
+# For starship (add to starship.toml)
+# [custom.claude_flow]
+# command = "node .claude/helpers/statusline.cjs 2>/dev/null"
+# when = "test -f .claude/helpers/statusline.cjs"
+`;
+}
+//# sourceMappingURL=statusline-generator.js.map

package/dist/src/init/statusline-generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"statusline-generator.js","sourceRoot":"","sources":["../../../src/init/statusline-generator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH;;;;;;;;GAQG;AACH,MAAM,UAAU,wBAAwB,CAAC,OAAoB;IAC3D,MAAM,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAElC,oFAAoF;IACpF,OAAO;;;;;;;;;;;;;;;;;;aAkBI,MAAM,CAAC,OAAO;kBACT,MAAM,CAAC,YAAY;kBACnB,MAAM,CAAC,YAAY;eACtB,MAAM,CAAC,SAAS;eAChB,MAAM,CAAC,SAAS;qBACV,MAAM,CAAC,eAAe;qBACtB,MAAM,CAAC,eAAe;eAC5B,OAAO,CAAC,OAAO,CAAC,SAAS;eACzB,OAAO,CAAC,OAAO,CAAC,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsStC,CAAC;AACF,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,sBAAsB,CAAC,OAAoB;IACzD,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC;QAChC,OAAO,uBAAuB,CAAC;IACjC,CAAC;IAED,OAAO;;;;;;;;;;;;;;;;;;;;;CAqBR,CAAC;AACF,CAAC"}

package/dist/src/init/types.d.ts

@@ -0,0 +1,246 @@
+/**
+ * V3 Init System Types
+ * Configuration options for initializing Claude Code integration
+ */
+/**
+ * Components that can be initialized
+ */
+export interface InitComponents {
+    /** Create .claude/settings.json with hooks */
+    settings: boolean;
+    /** Copy skills to .claude/skills/ */
+    skills: boolean;
+    /** Copy commands to .claude/commands/ */
+    commands: boolean;
+    /** Copy agents to .claude/agents/ */
+    agents: boolean;
+    /** Create helper scripts in .claude/helpers/ */
+    helpers: boolean;
+    /** Configure statusline */
+    statusline: boolean;
+    /** Create MCP configuration */
+    mcp: boolean;
+    /** Create .claude-flow/ directory (V3 runtime) */
+    runtime: boolean;
+    /** Create CLAUDE.md with swarm guidance */
+    claudeMd: boolean;
+}
+/**
+ * Hook configuration options
+ */
+export interface HooksConfig {
+    /** Enable PreToolUse hooks */
+    preToolUse: boolean;
+    /** Enable PostToolUse hooks */
+    postToolUse: boolean;
+    /** Enable UserPromptSubmit for routing */
+    userPromptSubmit: boolean;
+    /** Enable SessionStart hooks */
+    sessionStart: boolean;
+    /** Enable Stop hooks */
+    stop: boolean;
+    /** Enable Notification hooks */
+    notification: boolean;
+    /** Enable PermissionRequest auto-allow for claude-flow */
+    permissionRequest: boolean;
+    /** Hook timeout in milliseconds */
+    timeout: number;
+    /** Continue on hook error */
+    continueOnError: boolean;
+}
+/**
+ * Skills configuration
+ */
+export interface SkillsConfig {
+    /** Include core skills (swarm, memory, sparc) */
+    core: boolean;
+    /** Include AgentDB skills */
+    agentdb: boolean;
+    /** Include GitHub integration skills */
+    github: boolean;
+    /** Include Flow Nexus skills */
+    flowNexus: boolean;
+    /** Include V3 implementation skills */
+    v3: boolean;
+    /** Include all available skills */
+    all: boolean;
+}
+/**
+ * Commands configuration
+ */
+export interface CommandsConfig {
+    /** Include core commands */
+    core: boolean;
+    /** Include analysis commands */
+    analysis: boolean;
+    /** Include automation commands */
+    automation: boolean;
+    /** Include github commands */
+    github: boolean;
+    /** Include hooks commands */
+    hooks: boolean;
+    /** Include monitoring commands */
+    monitoring: boolean;
+    /** Include optimization commands */
+    optimization: boolean;
+    /** Include SPARC commands */
+    sparc: boolean;
+    /** Include all commands */
+    all: boolean;
+}
+/**
+ * Agents configuration
+ */
+export interface AgentsConfig {
+    /** Include core agents (coder, tester, reviewer) */
+    core: boolean;
+    /** Include consensus agents */
+    consensus: boolean;
+    /** Include GitHub agents */
+    github: boolean;
+    /** Include hive-mind agents */
+    hiveMind: boolean;
+    /** Include SPARC agents */
+    sparc: boolean;
+    /** Include swarm coordinators */
+    swarm: boolean;
+    /** Include V3-specific agents (security, memory, performance, etc.) */
+    v3: boolean;
+    /** Include optimization agents */
+    optimization: boolean;
+    /** Include testing agents */
+    testing: boolean;
+    /** Include all agents */
+    all: boolean;
+}
+/**
+ * Statusline configuration
+ */
+export interface StatuslineConfig {
+    /** Enable statusline */
+    enabled: boolean;
+    /** Show V3 progress */
+    showProgress: boolean;
+    /** Show security status */
+    showSecurity: boolean;
+    /** Show swarm activity */
+    showSwarm: boolean;
+    /** Show hooks metrics */
+    showHooks: boolean;
+    /** Show performance targets */
+    showPerformance: boolean;
+    /** Refresh interval in milliseconds */
+    refreshInterval: number;
+}
+/**
+ * MCP configuration
+ */
+export interface MCPConfig {
+    /** Include claude-flow MCP server */
+    claudeFlow: boolean;
+    /** Include ruv-swarm MCP server */
+    ruvSwarm: boolean;
+    /** Include flow-nexus MCP server */
+    flowNexus: boolean;
+    /** Auto-start MCP server */
+    autoStart: boolean;
+    /** Server port */
+    port: number;
+}
+/**
+ * Runtime configuration (.claude-flow/)
+ */
+export interface RuntimeConfig {
+    /** Swarm topology */
+    topology: 'mesh' | 'hierarchical' | 'hierarchical-mesh' | 'adaptive';
+    /** Maximum agents */
+    maxAgents: number;
+    /** Memory backend */
+    memoryBackend: 'memory' | 'sqlite' | 'agentdb' | 'hybrid';
+    /** Enable HNSW indexing */
+    enableHNSW: boolean;
+    /** Enable neural learning */
+    enableNeural: boolean;
+}
+/**
+ * Detected platform information
+ */
+export interface PlatformInfo {
+    /** Operating system */
+    os: 'windows' | 'darwin' | 'linux';
+    /** Architecture */
+    arch: 'x64' | 'arm64' | 'arm' | 'ia32';
+    /** Node.js version */
+    nodeVersion: string;
+    /** Shell type */
+    shell: 'powershell' | 'cmd' | 'bash' | 'zsh' | 'sh';
+    /** Home directory */
+    homeDir: string;
+    /** Config directory (platform-specific) */
+    configDir: string;
+}
+/**
+ * Detect current platform
+ */
+export declare function detectPlatform(): PlatformInfo;
+/**
+ * Complete init options
+ */
+export interface InitOptions {
+    /** Target directory */
+    targetDir: string;
+    /** Source base directory for skills/commands/agents (optional) */
+    sourceBaseDir?: string;
+    /** Force overwrite existing files */
+    force: boolean;
+    /** Run in interactive mode */
+    interactive: boolean;
+    /** Components to initialize */
+    components: InitComponents;
+    /** Hooks configuration */
+    hooks: HooksConfig;
+    /** Skills configuration */
+    skills: SkillsConfig;
+    /** Commands configuration */
+    commands: CommandsConfig;
+    /** Agents configuration */
+    agents: AgentsConfig;
+    /** Statusline configuration */
+    statusline: StatuslineConfig;
+    /** MCP configuration */
+    mcp: MCPConfig;
+    /** Runtime configuration */
+    runtime: RuntimeConfig;
+}
+/**
+ * Default init options - full V3 setup
+ */
+export declare const DEFAULT_INIT_OPTIONS: InitOptions;
+/**
+ * Minimal init options
+ */
+export declare const MINIMAL_INIT_OPTIONS: InitOptions;
+/**
+ * Full init options (everything enabled)
+ */
+export declare const FULL_INIT_OPTIONS: InitOptions;
+/**
+ * Init result
+ */
+export interface InitResult {
+    success: boolean;
+    platform: PlatformInfo;
+    created: {
+        directories: string[];
+        files: string[];
+    };
+    skipped: string[];
+    errors: string[];
+    summary: {
+        skillsCount: number;
+        commandsCount: number;
+        agentsCount: number;
+        hooksEnabled: number;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/init/types.d.ts.map

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