ctxman 3.0.0 → 3.1.1

package/lib/search/code-units.js

@@ -0,0 +1,201 @@
+/**
+ * Code units of a source file: methods/functions (from the existing method analyzers) and
+ * class-like declarations, each with the line range of its source.
+ *
+ * Shared by the ranked search (lib/search/bm25.js) and symbol lookup (lib/search/symbols.js).
+ */
+
+import path from 'path';
+import MethodAnalyzer from '../analyzers/method-analyzer.js';
+
+/** Extensions the method analyzers understand; other files have no code units */
+export const CODE_EXTENSIONS = new Set([
+  '.js',
+  '.jsx',
+  '.mjs',
+  '.cjs',
+  '.ts',
+  '.tsx',
+  '.mts',
+  '.cts',
+  '.rs',
+  '.go',
+  '.java',
+  '.cs',
+  '.py',
+  '.php',
+  '.rb',
+  '.kt',
+  '.kts',
+  '.swift',
+  '.c',
+  '.cpp',
+  '.cc',
+  '.h',
+  '.hpp',
+  '.scala',
+]);
+
+const MAX_AVERAGE_LINE_LENGTH = 250;
+
+// Modifiers that may precede a class-like keyword in the brace languages
+const MODIFIERS =
+  '(?:(?:export|default|declare|public|private|protected|internal|static|abstract|final|sealed|' +
+  'partial|open|data|inner|value|annotation|readonly|override|case|implicit|lazy|unsafe|' +
+  'pub(?:\\([^)]*\\))?|fileprivate)\\s+)*';
+
+const CLASS_PATTERNS = {
+  brace: new RegExp(
+    `^[ \\t]*${MODIFIERS}(class|interface|enum(?:\\s+(?:class|struct))?|struct|record|trait|object|protocol|extension|union)\\s+([A-Za-z_$][\\w$]*)`,
+    'gm'
+  ),
+  rustImpl:
+    /^[ \t]*(?:unsafe\s+)?impl(?:\s*<[^>]*>)?\s+(?:[\w:]+(?:<[^>]*>)?\s+for\s+)?([A-Za-z_]\w*)/gm,
+  goType: /^type\s+([A-Za-z_]\w*)\s+(struct|interface)\b/gm,
+  python: /^[ \t]*class\s+([A-Za-z_]\w*)/gm,
+  ruby: /^[ \t]*(class|module)\s+([A-Z]\w*(?:::\w+)*)/gm,
+};
+
+const analyzer = new MethodAnalyzer();
+
+/**
+ * Function mapping a string index to its 1-based line number
+ * @param {string} content
+ * @returns {(index: number) => number}
+ */
+function lineLocator(content) {
+  const breaks = [];
+  for (let i = content.indexOf('\n'); i !== -1; i = content.indexOf('\n', i + 1)) breaks.push(i);
+  return (index) => {
+    // Number of line breaks before `index`
+    let low = 0;
+    let high = breaks.length;
+    while (low < high) {
+      const mid = (low + high) >> 1;
+      if (breaks[mid] < index) low = mid + 1;
+      else high = mid;
+    }
+    return low + 1;
+  };
+}
+
+/**
+ * Class-like declarations (classes, interfaces, structs, enums, traits, modules, impl blocks)
+ * @param {string} content
+ * @param {string} ext - Lower-case file extension
+ * @returns {Array<{name: string, kind: string, line: number}>}
+ */
+function findClassDeclarations(content, ext) {
+  const found = [];
+  const lineAt = lineLocator(content);
+  const collect = (regex, pick) => {
+    for (const match of content.matchAll(regex)) {
+      const { name, kind } = pick(match);
+      found.push({ name, kind, line: lineAt(match.index + match[0].lastIndexOf(name)) });
+    }
+  };
+
+  if (ext === '.py') {
+    collect(CLASS_PATTERNS.python, (m) => ({ name: m[1], kind: 'class' }));
+  } else if (ext === '.rb') {
+    collect(CLASS_PATTERNS.ruby, (m) => ({ name: m[2], kind: m[1] }));
+  } else if (ext === '.go') {
+    collect(CLASS_PATTERNS.goType, (m) => ({ name: m[1], kind: m[2] }));
+  } else {
+    collect(CLASS_PATTERNS.brace, (m) => ({ name: m[2], kind: m[1].replace(/\s+/g, ' ') }));
+    if (ext === '.rs') {
+      collect(CLASS_PATTERNS.rustImpl, (m) => ({ name: m[1], kind: 'impl' }));
+    }
+  }
+  return found;
+}
+
+/**
+ * Methods, functions and class-like declarations of a file with their line ranges.
+ *
+ * Method ranges come from MethodAnalyzer.extractMethodSources(); class ranges use the same
+ * block rules (braces, Python indentation, Ruby `end`). Units are sorted by start line.
+ *
+ * @param {string} content - File content
+ * @param {string} filePath - Used for the language (extension)
+ * @returns {Array<{name: string, kind: string, startLine: number, endLine: number,
+ *   container?: boolean, parent?: string}>} `container` marks class-like declarations;
+ *   `parent` names the class-like declaration a method lies in
+ */
+export function extractCodeUnits(content, filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  if (!CODE_EXTENSIONS.has(ext)) return [];
+
+  const lines = content.split('\n');
+  // Minified or generated code: the regex analyzers crawl over very long lines and find
+  // nothing useful, so such files are searched by line windows only
+  if (content.length / lines.length > MAX_AVERAGE_LINE_LENGTH) return [];
+  let methods = [];
+  try {
+    methods = analyzer.extractMethods(content, filePath);
+  } catch (_error) {
+    // A regex analyzer failing on odd input leaves the file to the line windows
+  }
+  const methodSources = analyzer.extractMethodSources(content, methods, filePath);
+  const units = methods.map((method, i) => ({
+    name: method.name,
+    kind: method.type || 'function',
+    startLine: method.line,
+    endLine: method.line + methodSources[i].split('\n').length - 1,
+  }));
+
+  const classes = findClassDeclarations(content, ext);
+  const starts = [...new Set([...units, ...classes].map((u) => u.startLine ?? u.line))].sort(
+    (a, b) => a - b
+  );
+  for (const decl of classes) {
+    const start = decl.line - 1;
+    let end;
+    if (ext === '.py') {
+      end = analyzer.findIndentedBlockEnd(lines, start);
+    } else if (ext === '.rb') {
+      end = analyzer.findRubyBlockEnd(lines, start);
+    } else if (ext === '.go') {
+      end = analyzer.findBraceBlockEnd(lines, start, lines.length);
+    } else {
+      // A declaration without a body (`class Foo;`, `case class Foo(x: Int)`) must not run
+      // into the body of the next unit
+      const next = starts.find((line) => line > decl.line);
+      end = analyzer.findBraceBlockEnd(lines, start, next ? next - 1 : lines.length);
+    }
+    units.push({
+      name: decl.name,
+      kind: decl.kind,
+      startLine: decl.line,
+      endLine: end + 1,
+      container: true,
+    });
+  }
+
+  units.sort((a, b) => a.startLine - b.startLine || b.endLine - a.endLine);
+
+  // Go methods belong to their receiver type: `func (s *Server) Start()`
+  if (ext === '.go') {
+    for (const unit of units) {
+      const receiver = /^\s*func\s*\(\s*(?:\w+\s+)?\*?\s*([A-Za-z_]\w*)/.exec(
+        lines[unit.startLine - 1] ?? ''
+      );
+      if (receiver && !unit.container) unit.parent = receiver[1];
+    }
+  }
+
+  // Functions inside a class-like block are its methods
+  const containers = units.filter((unit) => unit.container);
+  for (const unit of units) {
+    if (unit.container) continue;
+    const parent = containers
+      .filter((c) => c.startLine < unit.startLine && c.endLine >= unit.endLine)
+      .at(-1);
+    if (parent) {
+      unit.parent = parent.name;
+      if (unit.kind === 'function') unit.kind = 'method';
+    }
+  }
+
+  return units;
+}

package/lib/search/symbols.js

@@ -0,0 +1,189 @@
+/**
+ * Symbol lookup: the full source of a named method, function or class.
+ *
+ * Names are matched exactly first, then ignoring case; when neither finds anything, similar
+ * names are suggested. `Class.method` (also `Class::method`, `Class#method`) narrows the
+ * lookup to methods of that class.
+ */
+
+import path from 'path';
+import TokenUtils from '../utils/token-utils.js';
+import { redactSecrets } from '../utils/secret-redactor.js';
+import { compareStrings, fitToTokenBudget, getProjectIndex, sliceLines } from './bm25.js';
+
+export const DEFAULT_SYMBOL_LIMIT = 10;
+export const DEFAULT_SYMBOL_MAX_TOKENS = 20000;
+const MAX_SUGGESTIONS = 10;
+
+/**
+ * Name without an accessor prefix: `get value` -> `value`
+ * @param {string} name
+ * @returns {string}
+ */
+function bareName(name) {
+  return name.replace(/^(?:get|set)\s+/, '');
+}
+
+/**
+ * Edit distance between two strings, or `max + 1` once it is certain to exceed `max`
+ * @param {string} a
+ * @param {string} b
+ * @param {number} [max=Infinity]
+ * @returns {number}
+ */
+export function editDistance(a, b, max = Infinity) {
+  if (Math.abs(a.length - b.length) > max) return max + 1;
+  let previous = Array.from({ length: b.length + 1 }, (_, j) => j);
+  for (let i = 1; i <= a.length; i++) {
+    const current = [i];
+    let rowMin = i;
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      current[j] = Math.min(previous[j] + 1, current[j - 1] + 1, previous[j - 1] + cost);
+      rowMin = Math.min(rowMin, current[j]);
+    }
+    if (rowMin > max) return max + 1;
+    previous = current;
+  }
+  return previous[b.length];
+}
+
+/**
+ * Split a qualified name: `Store.get`, `Store::get` and `Store#get` give
+ * `{ parent: 'Store', name: 'get' }`
+ * @param {string} query
+ * @returns {{parent: string|null, name: string}}
+ */
+export function parseSymbolQuery(query) {
+  const match = /^(.+?)(?:\.|::|#)([^.:#]+)$/.exec(query);
+  return match ? { parent: match[1], name: match[2] } : { parent: null, name: query };
+}
+
+/**
+ * Similar names for a query that matched nothing
+ * @private
+ */
+function suggest(candidates, name) {
+  const query = name.toLowerCase();
+  const threshold = Math.max(2, Math.floor(query.length / 3));
+  const best = new Map();
+  for (const { entry, unit } of candidates) {
+    const candidate = bareName(unit.name);
+    const lower = candidate.toLowerCase();
+    let distance = editDistance(lower, query, threshold);
+    // `user` suggests `getUserName`: containment counts as close
+    const shorter = Math.min(lower.length, query.length);
+    if (shorter >= 3 && (lower.includes(query) || query.includes(lower))) {
+      distance = Math.min(distance, 1);
+    }
+    if (distance > threshold || best.has(candidate)) continue;
+    best.set(candidate, {
+      name: unit.name,
+      kind: unit.kind,
+      ...(unit.parent ? { parent: unit.parent } : {}),
+      file: entry.relativePath,
+      startLine: unit.startLine,
+      distance,
+    });
+  }
+  return [...best.values()]
+    .sort(
+      (a, b) =>
+        a.distance - b.distance ||
+        Math.abs(a.name.length - query.length) - Math.abs(b.name.length - query.length) ||
+        compareStrings(a.name, b.name)
+    )
+    .slice(0, MAX_SUGGESTIONS)
+    .map(({ distance: _distance, ...rest }) => rest);
+}
+
+/**
+ * Find the units named by a query
+ * @param {Array<{entry: Object, unit: Object}>} candidates - Units with their file entries
+ * @param {string} query - `name` or `Parent.name`
+ * @returns {{match: 'exact'|'case-insensitive'|'none', found: Array, suggestions: Array}}
+ */
+export function lookupSymbols(candidates, query) {
+  const { parent, name } = parseSymbolQuery(query);
+  const tiers = [
+    ['exact', (a, b) => a === b],
+    ['case-insensitive', (a, b) => a.toLowerCase() === b.toLowerCase()],
+  ];
+
+  for (const [match, same] of tiers) {
+    const named = (unitName, wanted) => same(unitName, wanted) || same(bareName(unitName), wanted);
+    const found = candidates.filter(
+      ({ unit }) =>
+        named(unit.name, query) ||
+        (parent !== null && unit.parent && same(unit.parent, parent) && named(unit.name, name))
+    );
+    if (found.length > 0) return { match, found, suggestions: [] };
+  }
+  return { match: 'none', found: [], suggestions: suggest(candidates, name) };
+}
+
+/**
+ * Source of the methods, functions or classes with a given name in a project.
+ *
+ * @param {string} root - Project directory (files found with the Scanner, so the ignore
+ *   rules apply)
+ * @param {string} query - Symbol name, or `Class.method`
+ * @param {Object} [options]
+ * @param {string} [options.file] - Only this project-relative file
+ * @param {number} [options.limit=10] - Maximum number of symbols returned with source
+ * @param {number} [options.maxTokens=20000] - Token budget for the sources; sources past it
+ *   are cut (`truncated: true`)
+ * @param {boolean} [options.redact=true] - Redact secrets in the sources
+ * @returns {{query: string, match: string, total: number, symbols: Array,
+ *   suggestions?: Array}}
+ * @throws {Error} When the query is empty or `file` is not a project file
+ */
+export function getSymbol(
+  root,
+  query,
+  { file, limit = DEFAULT_SYMBOL_LIMIT, maxTokens = DEFAULT_SYMBOL_MAX_TOKENS, redact = true } = {}
+) {
+  const wanted = typeof query === 'string' ? query.trim() : '';
+  if (!wanted) throw new Error('The symbol name is empty');
+
+  const project = getProjectIndex(root);
+  let entries = [...project.files.values()];
+  if (file) {
+    const target = path.normalize(file);
+    entries = entries.filter((entry) => path.normalize(entry.relativePath) === target);
+    if (entries.length === 0) throw new Error(`File not found in project: ${file}`);
+  }
+
+  const candidates = entries.flatMap((entry) => entry.units.map((unit) => ({ entry, unit })));
+  const { match, found, suggestions } = lookupSymbols(candidates, wanted);
+
+  let used = 0;
+  const symbols = found.slice(0, Math.max(0, limit)).map(({ entry, unit }) => {
+    const raw = sliceLines(entry.content, unit.startLine, unit.endLine);
+    let source = redact ? redactSecrets(raw).text : raw;
+    let tokens = TokenUtils.calculate(source, entry.path);
+    const symbol = {
+      name: unit.name,
+      kind: unit.kind,
+      ...(unit.parent ? { parent: unit.parent } : {}),
+      file: entry.relativePath,
+      startLine: unit.startLine,
+      endLine: unit.endLine,
+    };
+    if (used + tokens > maxTokens) {
+      source = fitToTokenBudget(source, maxTokens - used, entry.path);
+      tokens = source ? TokenUtils.calculate(source, entry.path) : 0;
+      symbol.truncated = true;
+    }
+    used += tokens;
+    return { ...symbol, tokens, source };
+  });
+
+  return {
+    query: wanted,
+    match,
+    total: found.length,
+    symbols,
+    ...(match === 'none' ? { suggestions } : {}),
+  };
+}

package/lib/ui/dashboard.js

@@ -6,104 +6,135 @@ import { Box, Text, useInput, useStdin } from 'ink';
  * Real-time statistics and progress display
  */
 export default function Dashboard({ stats, topFiles = [], status = 'analyzing' }) {
-	const [shouldRefresh, setShouldRefresh] = useState(false);
-	const { isRawModeSupported } = useStdin();
+  const [shouldRefresh, setShouldRefresh] = useState(false);
+  const { isRawModeSupported } = useStdin();
 
-	// Keyboard controls
-	useInput((input, key) => {
-		if (input === 'r' || input === 'R') {
-			setShouldRefresh(!shouldRefresh);
-		}
-		if (input === 'q' || input === 'Q') {
-			process.exit(0);
-		}
-	}, { isActive: isRawModeSupported });
+  // Keyboard controls
+  useInput(
+    (input, _key) => {
+      if (input === 'r' || input === 'R') {
+        setShouldRefresh(!shouldRefresh);
+      }
+      if (input === 'q' || input === 'Q') {
+        process.exit(0);
+      }
+    },
+    { isActive: isRawModeSupported }
+  );
 
-	const {
-		totalFiles = 0,
-		totalTokens = 0,
-		totalBytes = 0,
-		totalLines = 0,
-		byExtension = {}
-	} = stats;
+  const {
+    totalFiles = 0,
+    totalTokens = 0,
+    totalBytes = 0,
+    totalLines = 0,
+    byExtension = {},
+  } = stats;
 
-	const avgTokensPerFile = totalFiles > 0 ? Math.round(totalTokens / totalFiles) : 0;
-	const sizeInMB = (totalBytes / (1024 * 1024)).toFixed(2);
+  const avgTokensPerFile = totalFiles > 0 ? Math.round(totalTokens / totalFiles) : 0;
+  const sizeInMB = (totalBytes / (1024 * 1024)).toFixed(2);
 
-	// Get dominant language
-	const extensions = Object.entries(byExtension);
-	const dominant = extensions.length > 0
-		? extensions.sort((a, b) => b[1].count - a[1].count)[0]
-		: null;
+  // Get dominant language
+  const extensions = Object.entries(byExtension);
+  const dominant =
+    extensions.length > 0 ? extensions.sort((a, b) => b[1].count - a[1].count)[0] : null;
 
-	return React.createElement(Box, {
-		flexDirection: 'column',
-		padding: 1,
-		borderStyle: 'round',
-		borderColor: 'green',
-		width: 76  // Max width to prevent scrollbar overlap (reduced from 80)
-	},
-		React.createElement(Box, { marginBottom: 1 },
-			React.createElement(Text, { bold: true, color: 'green' }, '📊 Live Analysis Dashboard'),
-			React.createElement(Text, { color: 'gray' }, ` (${status})`)
-		),
+  return React.createElement(
+    Box,
+    {
+      flexDirection: 'column',
+      padding: 1,
+      borderStyle: 'round',
+      borderColor: 'green',
+      width: 76, // Max width to prevent scrollbar overlap (reduced from 80)
+    },
+    React.createElement(
+      Box,
+      { marginBottom: 1 },
+      React.createElement(Text, { bold: true, color: 'green' }, '📊 Live Analysis Dashboard'),
+      React.createElement(Text, { color: 'gray' }, ` (${status})`)
+    ),
 
-		// Summary Stats
-		React.createElement(Box, { flexDirection: 'column', marginBottom: 1 },
-			React.createElement(Box, null,
-				React.createElement(Text, null, 'Files: '),
-				React.createElement(Text, { bold: true, color: 'cyan' }, totalFiles.toLocaleString()),
-				React.createElement(Text, null, '    Methods: '),
-				React.createElement(Text, { bold: true, color: 'cyan' }, '-'),
-				React.createElement(Text, null, '    Tokens: '),
-				React.createElement(Text, { bold: true, color: 'cyan' }, totalTokens.toLocaleString())
-			),
+    // Summary Stats
+    React.createElement(
+      Box,
+      { flexDirection: 'column', marginBottom: 1 },
+      React.createElement(
+        Box,
+        null,
+        React.createElement(Text, null, 'Files: '),
+        React.createElement(Text, { bold: true, color: 'cyan' }, totalFiles.toLocaleString()),
+        React.createElement(Text, null, '    Methods: '),
+        React.createElement(Text, { bold: true, color: 'cyan' }, '-'),
+        React.createElement(Text, null, '    Tokens: '),
+        React.createElement(Text, { bold: true, color: 'cyan' }, totalTokens.toLocaleString())
+      ),
 
-			React.createElement(Box, null,
-				React.createElement(Text, null, 'Size: '),
-				React.createElement(Text, { bold: true, color: 'cyan' }, `${sizeInMB} MB`),
-				React.createElement(Text, null, '    Lines: '),
-				React.createElement(Text, { bold: true, color: 'cyan' }, totalLines.toLocaleString()),
-				React.createElement(Text, null, '    Avg: '),
-				React.createElement(Text, { bold: true, color: 'cyan' }, `${avgTokensPerFile.toLocaleString()} tok/file`)
-			)
-		),
+      React.createElement(
+        Box,
+        null,
+        React.createElement(Text, null, 'Size: '),
+        React.createElement(Text, { bold: true, color: 'cyan' }, `${sizeInMB} MB`),
+        React.createElement(Text, null, '    Lines: '),
+        React.createElement(Text, { bold: true, color: 'cyan' }, totalLines.toLocaleString()),
+        React.createElement(Text, null, '    Avg: '),
+        React.createElement(
+          Text,
+          { bold: true, color: 'cyan' },
+          `${avgTokensPerFile.toLocaleString()} tok/file`
+        )
+      )
+    ),
 
-		// Top Languages
-		dominant && React.createElement(Box, { flexDirection: 'column', marginBottom: 1 },
-			React.createElement(Text, { bold: true }, 'Top Languages:'),
-			React.createElement(Box, { marginLeft: 2 },
-				React.createElement(Text, { color: 'green' }, '▓'.repeat(30)),
-				React.createElement(Text, null, ` ${dominant[0]} (${dominant[1].count} files)`)
-			)
-		),
+    // Top Languages
+    dominant &&
+      React.createElement(
+        Box,
+        { flexDirection: 'column', marginBottom: 1 },
+        React.createElement(Text, { bold: true }, 'Top Languages:'),
+        React.createElement(
+          Box,
+          { marginLeft: 2 },
+          React.createElement(Text, { color: 'green' }, '▓'.repeat(30)),
+          React.createElement(Text, null, ` ${dominant[0]} (${dominant[1].count} files)`)
+        )
+      ),
 
-		// Largest Files
-		topFiles.length > 0 && React.createElement(Box, { flexDirection: 'column', marginBottom: 1 },
-			React.createElement(Text, { bold: true }, 'Largest Files:'),
-			...topFiles.slice(0, 3).map((file, index) => {
-				const barLength = Math.round((file.tokens / topFiles[0].tokens) * 20);
-				const percentage = ((file.tokens / totalTokens) * 100).toFixed(1);
-				const fileName = (file.name || file.relativePath || file.path || 'unknown').substring(0, 30);
+    // Largest Files
+    topFiles.length > 0 &&
+      React.createElement(
+        Box,
+        { flexDirection: 'column', marginBottom: 1 },
+        React.createElement(Text, { bold: true }, 'Largest Files:'),
+        ...topFiles.slice(0, 3).map((file, index) => {
+          const barLength = Math.round((file.tokens / topFiles[0].tokens) * 20);
+          const percentage = ((file.tokens / totalTokens) * 100).toFixed(1);
+          const fileName = (file.name || file.relativePath || file.path || 'unknown').substring(
+            0,
+            30
+          );
 
-				return React.createElement(Box, { key: index, marginLeft: 2 },
-					React.createElement(Text, null, '• '),
-					React.createElement(Text, { color: 'cyan' }, fileName),
-					React.createElement(Text, null, ` ${file.tokens.toLocaleString()} tokens  `),
-					React.createElement(Text, { color: 'green' }, '▓'.repeat(barLength)),
-					React.createElement(Text, { color: 'gray' }, ` (${percentage}%)`)
-				);
-			})
-		),
+          return React.createElement(
+            Box,
+            { key: index, marginLeft: 2 },
+            React.createElement(Text, null, '• '),
+            React.createElement(Text, { color: 'cyan' }, fileName),
+            React.createElement(Text, null, ` ${file.tokens.toLocaleString()} tokens  `),
+            React.createElement(Text, { color: 'green' }, '▓'.repeat(barLength)),
+            React.createElement(Text, { color: 'gray' }, ` (${percentage}%)`)
+          );
+        })
+      ),
 
-		// Controls
-		React.createElement(Box, {
-			marginTop: 1,
-			borderStyle: 'single',
-			borderColor: 'gray',
-			padding: 1
-		},
-			React.createElement(Text, { dimColor: true }, '[R] Refresh  [S] Save  [E] Export  [Q] Quit')
-		)
-	);
+    // Controls
+    React.createElement(
+      Box,
+      {
+        marginTop: 1,
+        borderStyle: 'single',
+        borderColor: 'gray',
+        padding: 1,
+      },
+      React.createElement(Text, { dimColor: true }, '[R] Refresh  [S] Save  [E] Export  [Q] Quit')
+    )
+  );
 }

package/lib/ui/index.js

@@ -7,9 +7,4 @@ import { ProgressBar, SpinnerWithText } from './progress-bar.js';
 import Wizard from './wizard.js';
 import Dashboard from './dashboard.js';
 
-export {
-    ProgressBar,
-    SpinnerWithText,
-    Wizard,
-    Dashboard
-};
+export { ProgressBar, SpinnerWithText, Wizard, Dashboard };