kodu 2.1.3 → 3.0.1

package/src/core/file-system/fs.service.ts

@@ -1,248 +0,0 @@
-import { promises as fs, type Stats } from 'node:fs';
-import path from 'node:path';
-import { Injectable } from '@nestjs/common';
-import ignore from 'ignore';
-import { glob } from 'tinyglobby';
-import {
-  BINARY_EXTENSIONS,
-  KNOWN_TEXT_EXTENSIONS,
-  MAX_FILE_SIZE_BYTES,
-} from '../../shared/constants';
-import { ConfigService } from '../config/config.service';
-import { UiService } from '../ui/ui.service';
-
-const BINARY_PROBE_SIZE = 8192;
-const GLOB_IGNORE = ['.git/**'];
-
-type FindProjectFilesOptions = {
-  ignore?: string[];
-  useGitignore?: boolean;
-  excludeBinary?: boolean;
-  contentBasedBinaryDetection?: boolean;
-  maxFileSizeBytes?: number;
-  rootPaths?: string[];
-};
-
-@Injectable()
-export class FsService {
-  constructor(
-    private readonly configService: ConfigService,
-    private readonly ui: UiService,
-  ) {}
-
-  async findProjectFiles(
-    options: FindProjectFilesOptions = {},
-  ): Promise<string[]> {
-    const { packer } = this.configService.getConfig();
-    const shouldUseGitignore = options.useGitignore ?? packer.useGitignore;
-    const gitignorePatterns = shouldUseGitignore
-      ? await this.readIgnoreFile('.gitignore')
-      : [];
-    const koduignorePatterns = await this.readIgnoreFile('.koduignore');
-
-    const baseIgnore = options.ignore ?? packer.ignore ?? [];
-    const normalizedBase = this.normalizeIgnorePatterns(baseIgnore);
-    const combinedIgnore = [
-      ...normalizedBase,
-      ...gitignorePatterns,
-      ...koduignorePatterns,
-    ].map((pattern) => pattern.replace(/\\/g, '/'));
-
-    const ig = ignore();
-    if (combinedIgnore.length > 0) {
-      ig.add(combinedIgnore);
-    }
-
-    const globIgnore = this.buildGlobIgnorePatterns(combinedIgnore);
-
-    const patterns = options.rootPaths?.length
-      ? options.rootPaths.map((p) => `${p}/**`)
-      : ['**/*'];
-
-    const entries = await glob(patterns, {
-      onlyFiles: true,
-      absolute: true,
-      dot: true,
-      ignore: [...GLOB_IGNORE, ...globIgnore],
-    });
-
-    const relativePaths = entries
-      .map((entry) => path.relative(process.cwd(), entry))
-      .map((relative) => this.toPosixPath(relative))
-      .filter((relative) => relative.length > 0);
-
-    const filtered = ig
-      .filter(relativePaths)
-      .sort((a, b) => a.localeCompare(b));
-
-    // By default exclude binary files when collecting project files (so pack will skip them).
-    // Consumers can override with options.excludeBinary = false.
-    const excludeBinary = options.excludeBinary ?? true;
-    const useContentDetection =
-      options.contentBasedBinaryDetection ??
-      packer.contentBasedBinaryDetection ??
-      false;
-    const maxFileSize = options.maxFileSizeBytes ?? MAX_FILE_SIZE_BYTES;
-
-    const textFiles: string[] = [];
-
-    for (const rel of filtered) {
-      const abs = path.resolve(process.cwd(), rel);
-      let stats: Stats;
-
-      try {
-        stats = await fs.stat(abs);
-      } catch {
-        continue;
-      }
-
-      if (stats.size > maxFileSize) {
-        this.ui.log.warn(
-          `Skipping large file: ${rel} (>${(maxFileSize / (1024 * 1024)).toFixed(0)}MB)`,
-        );
-        continue;
-      }
-
-      if (
-        excludeBinary &&
-        (await this.shouldExcludeBinary(rel, abs, useContentDetection))
-      ) {
-        continue;
-      }
-
-      textFiles.push(rel);
-    }
-
-    return textFiles;
-  }
-
-  async readFileRelative(relativePath: string): Promise<string> {
-    const absolute = path.resolve(process.cwd(), relativePath);
-    return fs.readFile(absolute, 'utf8');
-  }
-
-  private toPosixPath(relativePath: string): string {
-    return relativePath.split(path.sep).join(path.posix.sep);
-  }
-
-  private normalizeIgnorePatterns(patterns: string[]): string[] {
-    return patterns
-      .map((pattern) => pattern.trim())
-      .filter((pattern) => pattern.length > 0 && !pattern.startsWith('#'));
-  }
-
-  private buildGlobIgnorePatterns(patterns: string[]): string[] {
-    const normalized = patterns
-      .map((pattern) => pattern.trim())
-      .filter(
-        (pattern) =>
-          pattern.length > 0 &&
-          !pattern.startsWith('#') &&
-          !pattern.startsWith('!'),
-      )
-      .map((pattern) => pattern.replace(/\\/g, '/'));
-
-    const result = new Set<string>();
-
-    for (const pattern of normalized) {
-      const trimmed = pattern.replace(/\/+$/, '');
-      result.add(pattern);
-
-      if (trimmed.length === 0) {
-        continue;
-      }
-
-      if (!pattern.includes('*')) {
-        result.add(`${trimmed}/**`);
-        result.add(`**/${trimmed}/**`);
-      }
-
-      if (!pattern.startsWith('**/')) {
-        result.add(`**/${trimmed}`);
-      }
-
-      if (pattern.endsWith('/')) {
-        result.add(`${trimmed}/**`);
-      }
-    }
-
-    return [...result];
-  }
-
-  private async readIgnoreFile(fileName: string): Promise<string[]> {
-    const target = path.join(process.cwd(), fileName);
-
-    try {
-      const content = await fs.readFile(target, 'utf8');
-      return this.parseIgnoreContent(content);
-    } catch {
-      return [];
-    }
-  }
-
-  private parseIgnoreContent(content: string): string[] {
-    return content
-      .split(/\r?\n/)
-      .map((line) => line.trim())
-      .filter((line) => line.length > 0 && !line.startsWith('#'));
-  }
-
-  private isBinaryExtension(relativePath: string): boolean {
-    const ext = path.extname(relativePath).toLowerCase();
-    return ext.length > 0 && BINARY_EXTENSIONS.has(ext);
-  }
-
-  private isKnownTextFile(relativePath: string): boolean {
-    const ext = path.extname(relativePath).toLowerCase();
-    if (ext && KNOWN_TEXT_EXTENSIONS.has(ext)) {
-      return true;
-    }
-
-    const baseName = path.basename(relativePath).toLowerCase();
-    return KNOWN_TEXT_EXTENSIONS.has(baseName);
-  }
-
-  private async shouldExcludeBinary(
-    relativePath: string,
-    absolutePath: string,
-    detectByContent: boolean,
-  ): Promise<boolean> {
-    if (this.isKnownTextFile(relativePath)) {
-      return false;
-    }
-
-    if (this.isBinaryExtension(relativePath)) {
-      return true;
-    }
-
-    if (!detectByContent) {
-      return false;
-    }
-
-    return this.hasNullByte(absolutePath);
-  }
-
-  private async hasNullByte(absolutePath: string): Promise<boolean> {
-    let handle: fs.FileHandle | undefined;
-
-    try {
-      handle = await fs.open(absolutePath, 'r');
-      const buffer = Buffer.alloc(BINARY_PROBE_SIZE);
-      const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
-
-      for (let i = 0; i < bytesRead; i += 1) {
-        if (buffer[i] === 0) {
-          return true;
-        }
-      }
-
-      return false;
-    } catch {
-      return true;
-    } finally {
-      if (handle) {
-        await handle.close();
-      }
-    }
-  }
-}

package/src/core/ui/ui.module.ts

@@ -1,9 +0,0 @@
-import { Global, Module } from '@nestjs/common';
-import { UiService } from './ui.service';
-
-@Global()
-@Module({
-  providers: [UiService],
-  exports: [UiService],
-})
-export class UiModule {}

package/src/core/ui/ui.service.ts

@@ -1,39 +0,0 @@
-import confirm from '@inquirer/confirm';
-import input from '@inquirer/input';
-import select from '@inquirer/select';
-import { Injectable } from '@nestjs/common';
-import pc from 'picocolors';
-import yoctoSpinner, {
-  type Spinner,
-  type Options as SpinnerOptions,
-} from 'yocto-spinner';
-
-type InputOptions = Parameters<typeof input>[0];
-type ConfirmOptions = Parameters<typeof confirm>[0];
-type SelectOptions<TValue> = Parameters<typeof select<TValue>>[0];
-
-@Injectable()
-export class UiService {
-  readonly log = {
-    success: (message: string) => console.log(pc.green(`✔ ${message}`)),
-    warn: (message: string) => console.log(pc.yellow(`⚠ ${message}`)),
-    error: (message: string) => console.log(pc.red(`✖ ${message}`)),
-    info: (message: string) => console.log(pc.cyan(`ℹ ${message}`)),
-  };
-
-  createSpinner(options?: SpinnerOptions & { text?: string }): Spinner {
-    return yoctoSpinner({ text: options?.text ?? '', ...options });
-  }
-
-  promptInput(options: InputOptions): Promise<string> {
-    return input(options);
-  }
-
-  promptConfirm(options: ConfirmOptions): Promise<boolean> {
-    return confirm(options);
-  }
-
-  promptSelect<TValue>(options: SelectOptions<TValue>): Promise<TValue> {
-    return select<TValue>(options);
-  }
-}

package/src/main.ts

@@ -1,12 +0,0 @@
-#!/usr/bin/env node
-
-import { CommandFactory } from 'nest-commander';
-import packageJson from '../package.json';
-import { AppModule } from './app.module';
-
-async function bootstrap() {
-  await CommandFactory.run(AppModule, {
-    version: packageJson.version,
-  });
-}
-bootstrap();

package/src/shared/cleaner/cleaner.service.ts

@@ -1,289 +0,0 @@
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-import { Injectable } from '@nestjs/common';
-import { Project, type SourceFile, SyntaxKind, ts } from 'ts-morph';
-import { ConfigService } from '../../core/config/config.service';
-import { FsService } from '../../core/file-system/fs.service';
-import {
-  type CleanOptions,
-  type CleanSummary,
-  type FileCleanReport,
-} from './cleaner.types';
-
-type RemovalRange = {
-  start: number;
-  end: number;
-  text: string;
-  kind: 'comment' | 'jsx';
-};
-
-@Injectable()
-export class CleanerService {
-  private readonly project = new Project({
-    useInMemoryFileSystem: false,
-    skipFileDependencyResolution: true,
-    compilerOptions: {
-      allowJs: true,
-      jsx: ts.JsxEmit.Preserve,
-    },
-  });
-
-  private readonly systemWhitelist = [
-    '@ts-ignore',
-    '@ts-expect-error',
-    'eslint-disable',
-    'prettier-ignore',
-    'biome-ignore',
-    'todo',
-    'fixme',
-  ];
-
-  constructor(
-    private readonly configService: ConfigService,
-    private readonly fsService: FsService,
-  ) {}
-
-  cleanContent(filename: string, content: string, keepJSDoc?: boolean): string {
-    const config = this.configService.getConfig();
-    const whitelist = this.buildWhitelist(config.cleaner.whitelist);
-    const shouldKeepJSDoc = keepJSDoc ?? config.cleaner.keepJSDoc;
-    const result = this.cleanSource(
-      filename,
-      content,
-      whitelist,
-      shouldKeepJSDoc,
-    );
-    return result.nextContent;
-  }
-
-  async cleanFiles(
-    files: string[],
-    options: CleanOptions = {},
-  ): Promise<CleanSummary> {
-    const config = this.configService.getConfig();
-    const whitelist = this.buildWhitelist(config.cleaner.whitelist);
-    const keepJSDoc = options.keepJSDoc ?? config.cleaner.keepJSDoc;
-    let commentsRemoved = 0;
-    let filesChanged = 0;
-    let bytesBefore = 0;
-    let bytesAfter = 0;
-    const reports: FileCleanReport[] = [];
-
-    for (let i = 0; i < files.length; i++) {
-      const file = files[i] as string;
-      options.onProgress?.(i + 1, files.length);
-
-      const original = await this.fsService.readFileRelative(file);
-      bytesBefore += Buffer.byteLength(original, 'utf8');
-
-      const result = this.cleanSource(file, original, whitelist, keepJSDoc);
-      bytesAfter += Buffer.byteLength(result.nextContent, 'utf8');
-
-      if (result.removed > 0) {
-        filesChanged += 1;
-        commentsRemoved += result.removed;
-
-        if (!options.dryRun) {
-          if (options.backup) {
-            await this.backupFile(file, original);
-          }
-          await this.writeFile(file, result.nextContent);
-        }
-      }
-
-      reports.push({
-        file,
-        removed: result.removed,
-        previews: result.previews,
-        bytesBefore: Buffer.byteLength(original, 'utf8'),
-        bytesAfter: Buffer.byteLength(result.nextContent, 'utf8'),
-      });
-    }
-
-    return {
-      filesProcessed: files.length,
-      filesChanged,
-      commentsRemoved,
-      bytesBefore,
-      bytesAfter,
-      reports,
-    };
-  }
-
-  private cleanSource(
-    file: string,
-    content: string,
-    whitelist: Set<string>,
-    keepJSDoc: boolean,
-  ): { nextContent: string; removed: number; previews: string[] } {
-    const sourceFile = this.project.createSourceFile(file, content, {
-      overwrite: true,
-    });
-    const fullText = sourceFile.getFullText();
-
-    const ranges = this.collectCommentRanges(sourceFile, file);
-    const candidates = ranges.filter((range) =>
-      this.shouldRemove(range, whitelist, keepJSDoc),
-    );
-
-    if (candidates.length === 0) {
-      return { nextContent: content, removed: 0, previews: [] };
-    }
-
-    const previews = candidates.map((range) =>
-      this.normalizePreview(range.text),
-    );
-
-    const sorted = [...candidates].sort((a, b) => b.start - a.start);
-    let nextContent = fullText;
-
-    for (const range of sorted) {
-      const replacement = this.getReplacement(fullText, range);
-      nextContent = `${nextContent.slice(0, range.start)}${replacement}${nextContent.slice(range.end)}`;
-    }
-
-    return { nextContent, removed: candidates.length, previews };
-  }
-
-  private collectCommentRanges(
-    sourceFile: SourceFile,
-    file: string,
-  ): RemovalRange[] {
-    const fullText = sourceFile.getFullText();
-    const ranges = new Map<string, RemovalRange>();
-
-    const addRanges = (items: readonly ts.CommentRange[] | undefined) => {
-      if (!items) return;
-
-      for (const item of items) {
-        this.addRange(
-          ranges,
-          item.pos,
-          item.end,
-          fullText.slice(item.pos, item.end),
-        );
-      }
-    };
-
-    const visit = (node: ts.Node): void => {
-      addRanges(ts.getLeadingCommentRanges(fullText, node.getFullStart()));
-      addRanges(ts.getTrailingCommentRanges(fullText, node.getEnd()));
-      ts.forEachChild(node, visit);
-    };
-
-    visit(sourceFile.compilerNode);
-
-    const jsxExpressions = sourceFile.getDescendantsOfKind(
-      SyntaxKind.JsxExpression,
-    );
-    for (const jsx of jsxExpressions) {
-      if (jsx.getExpression()) continue;
-      const text = jsx.getText();
-      if (!text.includes('/*')) continue;
-
-      const start = jsx.getPos();
-      const end = jsx.getEnd();
-      this.addRange(ranges, start, end, fullText.slice(start, end), 'jsx');
-    }
-
-    if (this.shouldCollectHtmlComments(file)) {
-      this.collectHtmlCommentRanges(fullText, ranges);
-    }
-
-    return [...ranges.values()];
-  }
-
-  private shouldRemove(
-    range: RemovalRange,
-    whitelist: Set<string>,
-    keepJSDoc: boolean,
-  ): boolean {
-    const trimmed = range.text.trimStart();
-    if (keepJSDoc && trimmed.startsWith('/**')) {
-      return false;
-    }
-
-    const lower = range.text.toLowerCase();
-    for (const token of whitelist) {
-      if (lower.includes(token)) {
-        return false;
-      }
-    }
-
-    return true;
-  }
-
-  private normalizePreview(text: string): string {
-    const singleLine = text.replace(/\s+/g, ' ').trim();
-    if (singleLine.length <= 60) return singleLine;
-    return `${singleLine.slice(0, 57)}...`;
-  }
-
-  private getReplacement(original: string, range: RemovalRange): string {
-    if (range.kind === 'jsx') {
-      return '';
-    }
-
-    const before = range.start > 0 ? original[range.start - 1] : '';
-    const after = range.end < original.length ? original[range.end] : '';
-    const isIdentifier = (ch: string): boolean => /[A-Za-z0-9_$]/.test(ch);
-
-    if (isIdentifier(before) && isIdentifier(after)) {
-      return ' ';
-    }
-
-    return '';
-  }
-
-  private buildWhitelist(userList: string[]): Set<string> {
-    const normalized = userList.map((item) => item.toLowerCase());
-    return new Set([...this.systemWhitelist, ...normalized]);
-  }
-
-  private async writeFile(file: string, content: string): Promise<void> {
-    const absolute = path.resolve(process.cwd(), file);
-    await fs.writeFile(absolute, content, 'utf8');
-  }
-
-  private async backupFile(file: string, content: string): Promise<void> {
-    const backupDir = path.join(process.cwd(), '.kodu', 'backup');
-    const target = path.join(backupDir, file);
-    await fs.mkdir(path.dirname(target), { recursive: true });
-    await fs.writeFile(target, content, 'utf8');
-  }
-
-  private addRange(
-    ranges: Map<string, RemovalRange>,
-    start: number,
-    end: number,
-    text: string,
-    kind: RemovalRange['kind'] = 'comment',
-  ): void {
-    const key = `${start}:${end}`;
-    if (ranges.has(key)) return;
-    ranges.set(key, { start, end, text, kind });
-  }
-
-  private collectHtmlCommentRanges(
-    fullText: string,
-    ranges: Map<string, RemovalRange>,
-  ): void {
-    const htmlCommentRegex = /<!--[\s\S]*?-->/g;
-    let match: RegExpExecArray | null;
-
-    while (true) {
-      match = htmlCommentRegex.exec(fullText);
-      if (!match) {
-        break;
-      }
-      const [text] = match;
-      if (!text) continue;
-      this.addRange(ranges, match.index, match.index + text.length, text);
-    }
-  }
-
-  private shouldCollectHtmlComments(file: string): boolean {
-    const extension = path.extname(file).toLowerCase();
-    return extension === '.html' || extension === '.htm';
-  }
-}

package/src/shared/cleaner/cleaner.types.ts

@@ -1,23 +0,0 @@
-export type CleanOptions = {
-  dryRun?: boolean;
-  backup?: boolean;
-  keepJSDoc?: boolean;
-  onProgress?: (current: number, total: number) => void;
-};
-
-export type FileCleanReport = {
-  file: string;
-  removed: number;
-  previews: string[];
-  bytesBefore: number;
-  bytesAfter: number;
-};
-
-export type CleanSummary = {
-  filesProcessed: number;
-  filesChanged: number;
-  commentsRemoved: number;
-  bytesBefore: number;
-  bytesAfter: number;
-  reports: FileCleanReport[];
-};