@cod3vil/kount-cli 1.0.0

package/src/reporters/markdown.ts

@@ -0,0 +1,129 @@
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import type { ProjectStats } from '../plugins/types.js';
+
+const KOUNT_HEADER = '<!-- KOUNT:START -->';
+const KOUNT_FOOTER = '<!-- KOUNT:END -->';
+
+/**
+ * Generates a Markdown report string from ProjectStats.
+ */
+function generateMarkdownReport(stats: ProjectStats): string {
+  const totalLines = stats.pluginResults.get('TotalLines')?.summaryValue ?? 0;
+  const blankLines = stats.pluginResults.get('BlankLines')?.summaryValue ?? 0;
+  const commentLines = stats.pluginResults.get('CommentLines')?.summaryValue ?? 0;
+  const totalBytes = stats.pluginResults.get('FileSize')?.summaryValue ?? 0;
+  const codeLines = totalLines - blankLines - commentLines;
+  const codeRatio = totalLines > 0 ? ((codeLines / totalLines) * 100).toFixed(1) : '0.0';
+
+  const formatSize = (bytes: number): string => {
+    if (bytes < 1024) return `${bytes} B`;
+    if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  };
+
+  const lines: string[] = [];
+  lines.push(KOUNT_HEADER);
+  lines.push('');
+  lines.push('## Codebase Statistics');
+  lines.push('');
+  lines.push(`> Generated by [kount](https://github.com/kount) on ${stats.scannedAt.toLocaleDateString()}`);
+  lines.push('');
+
+  // Summary table
+  lines.push('### Summary');
+  lines.push('');
+  lines.push('| Metric | Value |');
+  lines.push('|--------|-------|');
+  lines.push(`| Files | ${stats.totalFiles.toLocaleString()} |`);
+  lines.push(`| Total Lines | ${totalLines.toLocaleString()} |`);
+  lines.push(`| Code Lines | ${codeLines.toLocaleString()} |`);
+  lines.push(`| Comment Lines | ${commentLines.toLocaleString()} |`);
+  lines.push(`| Blank Lines | ${blankLines.toLocaleString()} |`);
+  lines.push(`| Code Ratio | ${codeRatio}% |`);
+  lines.push(`| Total Size | ${formatSize(totalBytes)} |`);
+  lines.push('');
+
+  // Language distribution (descending %)
+  if (stats.languageDistribution.size > 0) {
+    const sortedLangs = [...stats.languageDistribution.entries()]
+      .sort((a, b) => b[1] - a[1]);
+
+    lines.push('### Language Distribution');
+    lines.push('');
+    lines.push('| Language | Files | % |');
+    lines.push('|----------|-------|---|');
+
+    for (const [lang, count] of sortedLangs) {
+      const pct = ((count / stats.totalFiles) * 100).toFixed(1);
+      lines.push(`| ${lang} | ${count} | ${pct}% |`);
+    }
+    lines.push('');
+  }
+
+  // Top 10 largest files
+  if (stats.largestFiles.length > 0) {
+    lines.push('### Top 10 Largest Files');
+    lines.push('');
+    lines.push('| # | File | Size |');
+    lines.push('|---|------|------|');
+
+    for (let i = 0; i < stats.largestFiles.length; i++) {
+      const file = stats.largestFiles[i];
+      const relPath = path.relative(stats.rootDir, file.filePath);
+      lines.push(`| ${i + 1} | \`${relPath}\` | ${formatSize(file.size)} |`);
+    }
+    lines.push('');
+  }
+
+  lines.push(KOUNT_FOOTER);
+  return lines.join('\n');
+}
+
+/**
+ * Writes the Markdown report to a file.
+ * - By default, if the file exists, appends/replaces the KOUNT section.
+ * - If `force` is true, overwrites the entire file.
+ *
+ * @param stats The aggregated project statistics.
+ * @param outputPath The target markdown file path (defaults to README.md in rootDir).
+ * @param force If true, overwrite the entire file instead of appending.
+ */
+export async function writeMarkdownReport(
+  stats: ProjectStats,
+  outputPath?: string,
+  force: boolean = false
+): Promise<string> {
+  const targetPath = outputPath ?? path.join(stats.rootDir, 'README.md');
+  const report = generateMarkdownReport(stats);
+
+  if (force) {
+    await fsp.writeFile(targetPath, report, 'utf8');
+    return targetPath;
+  }
+
+  // Try to read existing file and replace KOUNT section, or append
+  try {
+    const existing = await fsp.readFile(targetPath, 'utf8');
+
+    const startIdx = existing.indexOf(KOUNT_HEADER);
+    const endIdx = existing.indexOf(KOUNT_FOOTER);
+
+    if (startIdx !== -1 && endIdx !== -1) {
+      // Replace existing KOUNT section
+      const before = existing.substring(0, startIdx);
+      const after = existing.substring(endIdx + KOUNT_FOOTER.length);
+      await fsp.writeFile(targetPath, before + report + after, 'utf8');
+    } else {
+      // Append to the end
+      await fsp.writeFile(targetPath, existing + '\n\n' + report, 'utf8');
+    }
+  } catch {
+    // File doesn't exist — create new
+    await fsp.writeFile(targetPath, report, 'utf8');
+  }
+
+  return targetPath;
+}
+
+export { generateMarkdownReport };

package/src/reporters/terminal/Progress.tsx

@@ -0,0 +1,39 @@
+import { Box, Text } from 'ink';
+import React from 'react';
+
+interface ProgressProps {
+  current: number;
+  total: number;
+  currentFile: string;
+}
+
+/**
+ * Real-time progress indicator for the streaming scan.
+ * Shows a progress bar, percentage, and current file being processed.
+ * Follows ux-progress-indicators and render-partial-updates guidelines.
+ */
+export function Progress({ current, total, currentFile }: ProgressProps): React.ReactElement {
+  const percentage = total > 0 ? Math.round((current / total) * 100) : 0;
+  const barWidth = 30;
+  const filled = Math.round((percentage / 100) * barWidth);
+  const empty = barWidth - filled;
+
+  const bar = '█'.repeat(filled) + '░'.repeat(empty);
+
+  // Color transitions: red < 33%, yellow < 66%, green >= 66%
+  const barColor = percentage < 33 ? 'red' : percentage < 66 ? 'yellow' : 'green';
+
+  return (
+    <Box flexDirection="column" marginY={1}>
+      <Box>
+        <Text color="white" bold>Scanning: </Text>
+        <Text color={barColor}>{bar}</Text>
+        <Text color="white"> {percentage}%</Text>
+        <Text color="gray"> ({current}/{total})</Text>
+      </Box>
+      <Box marginTop={0}>
+        <Text color="gray" wrap="truncate-end">  {currentFile}</Text>
+      </Box>
+    </Box>
+  );
+}

package/src/reporters/terminal/Splash.tsx

@@ -0,0 +1,32 @@
+import { Box, Text } from 'ink';
+import React from 'react';
+
+const LOGO = `
+ ██╗  ██╗ ██████╗ ██╗   ██╗███╗   ██╗████████╗
+ ██║ ██╔╝██╔═══██╗██║   ██║████╗  ██║╚══██╔══╝
+ █████╔╝ ██║   ██║██║   ██║██╔██╗ ██║   ██║
+ ██╔═██╗ ██║   ██║██║   ██║██║╚██╗██║   ██║
+ ██║  ██╗╚██████╔╝╚██████╔╝██║ ╚████║   ██║
+ ╚═╝  ╚═╝ ╚═════╝  ╚═════╝ ╚═╝  ╚═══╝   ╚═╝`;
+
+/**
+ * Splash screen component that displays the KOUNT ASCII logo.
+ * Uses Ink's Box + Text for structured terminal rendering.
+ * Follows render-single-write and tuicomp-border-styles guidelines.
+ */
+export function Splash(): React.ReactElement {
+  return (
+    <Box
+      flexDirection="column"
+      borderStyle="round"
+      borderColor="cyan"
+      paddingX={2}
+      paddingY={1}
+    >
+      <Text color="cyan" bold>{LOGO}</Text>
+      <Box marginTop={1}>
+        <Text color="white" dimColor>  Project Intelligence for Codebases</Text>
+      </Box>
+    </Box>
+  );
+}

package/src/reporters/terminal/Summary.tsx

@@ -0,0 +1,135 @@
+import { Box, Text } from 'ink';
+import path from 'node:path';
+import React from 'react';
+import type { ProjectStats } from '../../plugins/types.js';
+
+interface SummaryProps {
+  stats: ProjectStats;
+}
+
+/**
+ * Final summary display after scan completes.
+ * Strict color-coding: green for success-like values, no emojis.
+ * Follows ux-color-semantics and ux-next-steps guidelines.
+ */
+export function Summary({ stats }: SummaryProps): React.ReactElement {
+  const totalLines = stats.pluginResults.get('TotalLines')?.summaryValue ?? 0;
+  const blankLines = stats.pluginResults.get('BlankLines')?.summaryValue ?? 0;
+  const commentLines = stats.pluginResults.get('CommentLines')?.summaryValue ?? 0;
+  const totalBytes = stats.pluginResults.get('FileSize')?.summaryValue ?? 0;
+  const codeLines = totalLines - blankLines - commentLines;
+  const codeRatio = totalLines > 0 ? ((codeLines / totalLines) * 100).toFixed(1) : '0.0';
+
+  // Format bytes
+  const formatSize = (bytes: number): string => {
+    if (bytes < 1024) return `${bytes} B`;
+    if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  };
+
+  // Sort language distribution descending
+  const sortedLangs = [...stats.languageDistribution.entries()]
+    .sort((a, b) => b[1] - a[1]);
+
+  return (
+    <Box flexDirection="column" marginY={1}>
+      {/* Summary Section */}
+      <Box
+        flexDirection="column"
+        borderStyle="single"
+        borderColor="green"
+        paddingX={2}
+        paddingY={1}
+      >
+        <Text color="green" bold>  SCAN RESULTS</Text>
+        <Box marginTop={1} flexDirection="column">
+          <Box>
+            <Box width={20}><Text color="white">Files</Text></Box>
+            <Text color="cyan" bold>{stats.totalFiles.toLocaleString()}</Text>
+          </Box>
+          <Box>
+            <Box width={20}><Text color="white">Total Lines</Text></Box>
+            <Text color="cyan" bold>{totalLines.toLocaleString()}</Text>
+          </Box>
+          <Box>
+            <Box width={20}><Text color="white">Code Lines</Text></Box>
+            <Text color="green" bold>{codeLines.toLocaleString()}</Text>
+          </Box>
+          <Box>
+            <Box width={20}><Text color="white">Comment Lines</Text></Box>
+            <Text color="yellow" bold>{commentLines.toLocaleString()}</Text>
+          </Box>
+          <Box>
+            <Box width={20}><Text color="white">Blank Lines</Text></Box>
+            <Text color="gray" bold>{blankLines.toLocaleString()}</Text>
+          </Box>
+          <Box>
+            <Box width={20}><Text color="white">Code Ratio</Text></Box>
+            <Text color="green" bold>{codeRatio}%</Text>
+          </Box>
+          <Box>
+            <Box width={20}><Text color="white">Total Size</Text></Box>
+            <Text color="cyan" bold>{formatSize(totalBytes)}</Text>
+          </Box>
+        </Box>
+      </Box>
+
+      {/* Language Distribution */}
+      {sortedLangs.length > 0 && (
+        <Box
+          flexDirection="column"
+          borderStyle="single"
+          borderColor="blue"
+          paddingX={2}
+          paddingY={1}
+          marginTop={1}
+        >
+          <Text color="blue" bold>  LANGUAGE DISTRIBUTION</Text>
+          <Box marginTop={1} flexDirection="column">
+            {sortedLangs.map(([lang, count]) => {
+              const pct = ((count / stats.totalFiles) * 100).toFixed(1);
+              return (
+                <Box key={lang}>
+                  <Box width={22}><Text color="white">{lang}</Text></Box>
+                  <Box width={8}><Text color="cyan">{count} files</Text></Box>
+                  <Text color="gray"> ({pct}%)</Text>
+                </Box>
+              );
+            })}
+          </Box>
+        </Box>
+      )}
+
+      {/* Largest Files */}
+      {stats.largestFiles.length > 0 && (
+        <Box
+          flexDirection="column"
+          borderStyle="single"
+          borderColor="magenta"
+          paddingX={2}
+          paddingY={1}
+          marginTop={1}
+        >
+          <Text color="magenta" bold>  TOP {stats.largestFiles.length} LARGEST FILES</Text>
+          <Box marginTop={1} flexDirection="column">
+            {stats.largestFiles.map((file, i) => {
+              const relPath = path.relative(stats.rootDir, file.filePath);
+              return (
+                <Box key={file.filePath}>
+                  <Box width={4}><Text color="gray">{i + 1}.</Text></Box>
+                  <Box width={40}><Text color="white" wrap="truncate-end">{relPath}</Text></Box>
+                  <Text color="yellow">{formatSize(file.size)}</Text>
+                </Box>
+              );
+            })}
+          </Box>
+        </Box>
+      )}
+
+      {/* Footer */}
+      <Box marginTop={1}>
+        <Text color="gray">Scanned at {stats.scannedAt.toLocaleString()}</Text>
+      </Box>
+    </Box>
+  );
+}

package/src/reporters/terminal/Wizard.tsx

@@ -0,0 +1,125 @@
+import { Box, Text, useApp, useInput } from 'ink';
+import React, { useCallback, useState } from 'react';
+
+export interface WizardResult {
+  rootDir: string;
+  outputMode: 'terminal' | 'markdown' | 'html';
+  includeTests: boolean;
+}
+
+interface WizardProps {
+  onComplete: (result: WizardResult) => void;
+}
+
+type Step = 'rootDir' | 'outputMode' | 'includeTests';
+
+const OUTPUT_MODES = ['terminal', 'markdown', 'html'] as const;
+
+/**
+ * Minimal interactive step-based wizard when no CLI flags are provided.
+ * Follows prompt-group-flow, input-useinput-hook, input-escape-routes guidelines.
+ */
+export function Wizard({ onComplete }: WizardProps): React.ReactElement {
+  const { exit } = useApp();
+  const [step, setStep] = useState<Step>('rootDir');
+  const [rootDir, setRootDir] = useState('.');
+  const [rootDirInput, setRootDirInput] = useState('.');
+  const [outputModeIndex, setOutputModeIndex] = useState(0);
+  const [includeTestsIndex, setIncludeTestsIndex] = useState(0);
+
+  const boolOptions = ['Yes', 'No'] as const;
+
+  useInput(useCallback((input: string, key: { return?: boolean; escape?: boolean; upArrow?: boolean; downArrow?: boolean; backspace?: boolean; delete?: boolean }) => {
+    // Escape route
+    if (key.escape) {
+      exit();
+      return;
+    }
+
+    if (step === 'rootDir') {
+      if (key.return) {
+        setRootDir(rootDirInput || '.');
+        setStep('outputMode');
+      } else if (key.backspace || key.delete) {
+        setRootDirInput(prev => prev.slice(0, -1));
+      } else if (input && !key.upArrow && !key.downArrow) {
+        setRootDirInput(prev => prev + input);
+      }
+    } else if (step === 'outputMode') {
+      if (key.upArrow) {
+        setOutputModeIndex(prev => (prev - 1 + OUTPUT_MODES.length) % OUTPUT_MODES.length);
+      } else if (key.downArrow) {
+        setOutputModeIndex(prev => (prev + 1) % OUTPUT_MODES.length);
+      } else if (key.return) {
+        setStep('includeTests');
+      }
+    } else if (step === 'includeTests') {
+      if (key.upArrow || key.downArrow) {
+        setIncludeTestsIndex(prev => (prev + 1) % 2);
+      } else if (key.return) {
+        onComplete({
+          rootDir: rootDir,
+          outputMode: OUTPUT_MODES[outputModeIndex],
+          includeTests: includeTestsIndex === 0,
+        });
+      }
+    }
+  }, [step, rootDirInput, rootDir, outputModeIndex, includeTestsIndex, onComplete, exit]));
+
+  return (
+    <Box flexDirection="column" paddingX={1} paddingY={1}>
+      <Text color="cyan" bold>KOUNT Setup Wizard</Text>
+      <Text color="gray">Press ESC to cancel at any time.</Text>
+      <Box marginTop={1} flexDirection="column">
+
+        {/* Step 1: Root Directory */}
+        <Box flexDirection="column">
+          <Text color={step === 'rootDir' ? 'white' : 'green'} bold>
+            {step === 'rootDir' ? '>' : '✓'} Root directory:
+            {step !== 'rootDir' && <Text color="cyan"> {rootDir}</Text>}
+          </Text>
+          {step === 'rootDir' && (
+            <Box marginLeft={2}>
+              <Text color="cyan">{rootDirInput}</Text>
+              <Text color="gray">█</Text>
+            </Box>
+          )}
+        </Box>
+
+        {/* Step 2: Output Mode */}
+        {(step === 'outputMode' || step === 'includeTests') && (
+          <Box flexDirection="column" marginTop={1}>
+            <Text color={step === 'outputMode' ? 'white' : 'green'} bold>
+              {step === 'outputMode' ? '>' : '✓'} Output mode:
+              {step !== 'outputMode' && <Text color="cyan"> {OUTPUT_MODES[outputModeIndex]}</Text>}
+            </Text>
+            {step === 'outputMode' && (
+              <Box marginLeft={2} flexDirection="column">
+                {OUTPUT_MODES.map((mode, i) => (
+                  <Text key={mode} color={i === outputModeIndex ? 'cyan' : 'gray'}>
+                    {i === outputModeIndex ? '> ' : '  '}{mode}
+                  </Text>
+                ))}
+              </Box>
+            )}
+          </Box>
+        )}
+
+        {/* Step 3: Include Tests */}
+        {step === 'includeTests' && (
+          <Box flexDirection="column" marginTop={1}>
+            <Text color="white" bold>{'>'} Include test files?</Text>
+            <Box marginLeft={2} flexDirection="column">
+              {boolOptions.map((opt, i) => (
+                <Text key={opt} color={i === includeTestsIndex ? 'cyan' : 'gray'}>
+                  {i === includeTestsIndex ? '> ' : '  '}{opt}
+                </Text>
+              ))}
+            </Box>
+          </Box>
+        )}
+
+      </Box>
+    </Box>
+  );
+}

package/src/reporters/terminal/index.ts

@@ -0,0 +1,6 @@
+export { Progress } from './Progress.js';
+export { Splash } from './Splash.js';
+export { Summary } from './Summary.js';
+export { Wizard } from './Wizard.js';
+export type { WizardResult } from './Wizard.js';
+

package/src/scanner/ignore-parser.ts

@@ -0,0 +1,168 @@
+import ignore, { Ignore } from 'ignore';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+const DEFAULT_IGNORES = [
+  'node_modules',
+  'dist',
+  'build',
+  '.git',
+  '.next',
+  '.nuxt',
+  'coverage',
+  '.kountcache.json', // Our own cache file
+];
+
+interface IgnoreContext {
+  ig: Ignore;
+  dir: string;
+}
+
+/**
+ * Parses ignore files and builds a matcher set for a given directory tree.
+ * Respects default ignores automatically.
+ */
+export class IgnoreParser {
+  // Store ignore instances keyed by directory path
+  private directoryIgnores = new Map<string, Ignore>();
+  private rootDir: string;
+  private respectGitignore: boolean;
+  
+  // Track binary extensions to filter out automatically
+  private static readonly BINARY_EXTENSIONS = new Set([
+    '.png', '.jpg', '.jpeg', '.gif', '.ico', '.svg', '.webp', '.tiff', '.bmp',
+    '.mp4', '.mkv', '.avi', '.mov', '.wmv', '.webm', '.flv',
+    '.mp3', '.wav', '.ogg', '.flac', '.aac', '.m4a',
+    '.pdf', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx',
+    '.zip', '.tar', '.gz', '.7z', '.rar', '.bz2', '.xz',
+    '.exe', '.dll', '.so', '.dylib', '.bin', '.dat', '.db', '.sqlite',
+    '.app', '.dmg', '.iso', '.class', '.jar', '.war', '.ear',
+    '.woff', '.woff2', '.ttf', '.eot', '.otf',
+    '.pyc', '.pyo', '.pyd', '.o', '.a', '.lib', '.out',
+    '.wasm'
+  ]);
+
+  constructor(rootDir: string, respectGitignore: boolean = true) {
+    this.rootDir = path.resolve(rootDir);
+    this.respectGitignore = respectGitignore;
+  }
+
+  /**
+   * Initializes the base ignores (defaults + root .kountignore/.gitignore).
+   * Call this before walking.
+   */
+  async init(): Promise<void> {
+    const rootIg = ignore().add(DEFAULT_IGNORES);
+    await this.loadIgnoreFiles(this.rootDir, rootIg);
+    this.directoryIgnores.set(this.rootDir, rootIg);
+  }
+
+  /**
+   * Loads `.gitignore` or `.kountignore` inside a specific directory.
+   */
+  async loadIgnoreForDir(dirPath: string): Promise<void> {
+    if (this.directoryIgnores.has(dirPath)) return;
+
+    // Inherit from parent directory (if any) or fallback to root if not loaded somehow
+    const parentDir = path.dirname(dirPath);
+    const parentIg = this.directoryIgnores.get(parentDir) || this.directoryIgnores.get(this.rootDir);
+    
+    // Create a new instance starting with parent's rules.  Wait, ignore doesn't deep clone easily.
+    // Instead, we just maintain a stack of ig instances during walk, but for class-level,
+    // we can create a fresh ignore and add parent's rules if we tracked them, OR just test
+    // a path against all ignores from root to current dir.
+    // For simplicity and speed: We will test a relative path against an array of ignores.
+    
+    // Actually, ignore is designed to be used by resolving paths relative to where the .gitignore is.
+    // Let's store rules per directory.
+    const ig = ignore();
+    const hasRules = await this.loadIgnoreFiles(dirPath, ig);
+    
+    // If no new rules, we don't strictly need to store it, but let's store undefined or similar
+    // to mark it processed.
+    if (hasRules) {
+        this.directoryIgnores.set(dirPath, ig);
+    }
+  }
+
+  /**
+   * Helper to append rules from files to an Ignore instance.
+   * Returns true if rules were added.
+   */
+  private async loadIgnoreFiles(dirPath: string, ig: Ignore): Promise<boolean> {
+    let hasRules = false;
+
+    // Load .kountignore first (custom rules overrides everything else if needed, though ignore merges them)
+    try {
+      const kountIgnorePath = path.join(dirPath, '.kountignore');
+      const kountRules = await fs.readFile(kountIgnorePath, 'utf8');
+      ig.add(kountRules);
+      hasRules = true;
+    } catch (e) { /* ignores missing file */ }
+
+    // Load .gitignore
+    if (this.respectGitignore) {
+      try {
+        const gitIgnorePath = path.join(dirPath, '.gitignore');
+        const gitRules = await fs.readFile(gitIgnorePath, 'utf8');
+        ig.add(gitRules);
+        hasRules = true;
+      } catch (e) { /* ignores missing file */ }
+    }
+
+    return hasRules;
+  }
+
+  /**
+   * Checks if an absolute path should be ignored.
+   */
+  isIgnored(absolutePath: string, isDirectory: boolean): boolean {
+    // 1. Binary check
+    if (!isDirectory) {
+      const ext = path.extname(absolutePath).toLowerCase();
+      if (IgnoreParser.BINARY_EXTENSIONS.has(ext)) {
+        return true;
+      }
+    }
+
+    // 2. Resolve relative to root to check against ignores
+    const relativeToRoot = path.relative(this.rootDir, absolutePath);
+    
+    // Edge case: if it evaluates to empty string (which means absolutePath == rootDir), don't ignore
+    if (relativeToRoot === '') return false;
+
+    // We need to check the path formatted for `ignore` package (forward slashes)
+    // and if it's a directory, adding a trailing slash helps `ignore` match dir-only rules eagerly.
+    const posixPath = relativeToRoot.split(path.sep).join('/');
+    const testPath = isDirectory ? `${posixPath}/` : posixPath;
+
+    // 3. Test against root ignores first (which contains defaults)
+    const rootIg = this.directoryIgnores.get(this.rootDir);
+    if (rootIg && rootIg.ignores(testPath)) {
+        return true;
+    }
+
+    // 4. Test against nested directory ignores (from root down to the file's dir)
+    // E.g. for src/components/Button.tsx, check src/ and src/components/
+    const parts = relativeToRoot.split(path.sep);
+    let currentPath = this.rootDir;
+
+    for (let i = 0; i < parts.length - 1; i++) { // -1 because we don't need to check in the file's own name as a dir
+      currentPath = path.join(currentPath, parts[i]);
+      const dirIg = this.directoryIgnores.get(currentPath);
+      
+      if (dirIg) {
+          // The ignore package checks paths relative to where the .gitignore file is located.
+          const relToIgnoreFile = path.relative(currentPath, absolutePath);
+          const relPosixPath = relToIgnoreFile.split(path.sep).join('/');
+          const nestedTestPath = isDirectory ? `${relPosixPath}/` : relPosixPath;
+          
+          if (dirIg.ignores(nestedTestPath)) {
+              return true;
+          }
+      }
+    }
+
+    return false;
+  }
+}